- obsolete

[packages/kernel.git] / 2.6.0-t5-enbd-2.4.31_20030506.patch

--- linux-2.5.64/drivers/block/Kconfig.pre-enbd Mon Mar 24 15:56:52 2003
+++ linux-2.5.64/drivers/block/Kconfig  Mon Mar 24 17:45:35 2003
@@ -292,6 +292,15 @@
 
          If unsure, say N.
 
+config ENBD
+        bool 'Enhanced network block device'
+       depends on NET
+        ---help---
+         To use the ENBD support, you must say Y here and select one
+         of the driver's units (e.g. BLK_DEV_ENBD, BLK_DEV_ENBD_IOCTL).
+
+source "drivers/block/enbd/Kconfig"
+
 config BLK_DEV_RAM
        tristate "RAM disk support"
        ---help---
--- linux-2.5.64/drivers/block/enbd/enbd_base.c.pre-enbd        Mon Mar 24 18:55:25 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_base.c Tue Mar 25 15:44:12 2003
@@ -0,0 +1,4172 @@
+/*
+ * (Enhanced) Network block device - make block devices work over TCP
+ *
+ * Original NBD Copyright 1997 Pavel Machek <pavel@elf.mj.gts.cz>
+ * Further ENBD Copyrights 1998, 1999, 2000 Peter Breuer <ptb@it.uc3m.es>
+ *
+ *
+ *
+ * ATTENTION: You need the userspace daemons available from
+ *            ftp://oboe.it.uc3m.es/pub/Programs/nbd-2.4.*.tgz
+ *            and/or the ENBD project on http://freshmeat.net
+ *
+ *
+ *
+ * Development of the ENBD software has been supported by grants and
+ * contributions from Realm Information Technologies, Inc. of 5555
+ * Oakbrook Parkway, NW Norcross, GA and iNsu Innovations Inc.  of
+ * 3465, Boulevard Thimens, Saint-Laurent, Quebec, Canada.
+ * 
+ * ------------ Pavel's history notes ----------------------------------
+ * 97-3-25 compiled 0-th version, not yet tested it 
+ *   (it did not work, BTW) (later that day) HEY! it works!
+ *   (bit later) hmm, not that much... 2:00am next day:
+ *   yes, it works, but it gives something like 50kB/sec
+ * 97-3-28 it's completely strange - when using 1024 byte "packets"
+ *   it gives 50kB/sec and CPU idle; with 2048 bytes it gives
+ *   500kB/sec (and CPU loaded 100% as it should be) (all done
+ *   against localhost)
+ * 97-4-1 complete rewrite to make it possible for many requests at 
+ *   once to be processed
+ * 97-4-1 23:57 rewrite once again to make it work :-(
+ * 97-4-3 00:02 hmm, it does not work.
+ * 97-4-3 23:06 hmm, it will need one more rewrite :-)
+ * 97-4-10 It looks like it's working and stable. But I still do not
+ *  have any recovery from lost connection...
+ * (setq tab-width 4)
+ * 97-4-11 Making protocol independent of endianity etc.
+ * 97-4-15 Probably one more rewrite, since it loses requests under
+ *  heavy loads
+ * 97-9-13 Cosmetic changes
+ *
+ * possible FIXME: make set_sock / set_blksize / set_size / do_it one syscall
+ * why not: would need verify_area and friends, would share yet another 
+ *          structure with userland
+ *
+ * FIXME: not module-safe
+ *
+ * ------------ Peter's history notes ----------------------------------
+ * 98-12-18 modules now OK ptb@it.uc3m.es (Peter Breuer) ported to
+ * 2.0.*. + better debugging. Still possible lockup in connection with APM
+ * and spurious interrupt - only on write. Error treatment should
+ * be improved. After 100 errors from end_request the kernel can
+ * do anything. We should catch it ourselves.
+ * 99-1-sometime fixed lockup by extending semaphore - ptb v1.0.
+ * 99-3-sometime reconnect protocol (client mod agreed by pavel) - ptb v1.1
+ * 99-4-25 add /proc/nbdinfo - ptb v1.1.1
+ * 99-4-sometime add multiplex - ptb v1.2
+ * 99-4-26 fix multiplex and redundancy - ptb v1.2.1
+ * 99-4-29 reentrant client threads - ptb v1.2.2
+ * 99-4-29 socket related stuff placed in user space - amarin v1.3.0
+ * 99-5-3  fix all, all writes had to be before all reads - ptb v1.2.4
+ * 99-5-5  fix out-of-order, async - ptb v1.2.5
+ * 99-5-7  semaphores removed (still works!), fail cases corrected - ptb v1.2.6
+ * 99-5-12 signals unblocked in xmit, blksize != 1024 fixed, ioctls
+ *         added  - ptb v1.2.7
+ * 99-6-1  interaction with client split into two functions - amarin v1.3.0
+ * 99-6-3  reintegrated fully, mem manager fixed, accounts fixed - ptb v1.2.8.3
+ * 99-6-3  extra queue removed, mem manager removed  - ptb v1.2.8.4
+ * 99-7-3  buffer registration introduced - ptb v1.2.8.5
+ * 99-7-3  some client redundancy reestablished - ptb v2.1.1
+ * 99-7-10 encapsulated queue calls. One element rollback buffer - ptb v2.1.2
+ * 99-7-20 timestamp and rollback old abandoned request - ptb v2.1.3
+ * 99-7-24 64bit file sizes and offsets accepted - ptb v2.1.9
+ * 99-7-26 experimental request coalesces - ptb v2.1.10
+ * 99-7-27 partitioning scheme - ptb v2.2.1
+ * 99-8-3  nbd_clr_sock bug in invalidate_device fixed? - ptb v2.2.4
+ * 99-8-5  reverse replace of block_fsync, add sig ioctls - ptb v2.2.5
+ *         reverse bug introduced about v2.2.3 for compound reqs - ptb v2.2.5
+ *         fix clear_que bug (didn't rollback first) from 2.1.3 - ptb v2.2.5
+ * 99-8-22 workaround strange nr_sectors bug - ptb v2.2.6
+ * 99-8-11 fix MY_NBD_SYNC bug. Never sync'ed all - ptb v2.2.7
+ * 99-8-12 wakeups all moved to enqueue - ptb v2.2.7
+ * 99-8-23 remove slot->cli_age - ptb v2.2.7
+ * 99-8-24 first 8 bytes of signature embedded in packets - ptb v2.2.8
+ *         fix SET_SIG define buglet, remove hardcoded constants - ptb v2.2.8
+ *         fix huge bug. Missing copy_fromfs in my_nbd_ack - ptb v2.2.8     
+ *         removed signature embedding and all other decorations - ptb v2.2.8
+ * 99-8-25 recast fix in my_nbd_ack to avoid align. bug - ptb v2.2.9
+ *         put in MKDEVs and put back some hardcode const fixes - ptb v2.2.10
+ * 99-9-29 fix BLKGETSIZE bug - ptb v2.2.14
+ * 99-10-2 run with interrupts on throughout. Think we lose some - ptb v2.2.15
+ * 99-10-8 trim dead code, kernel 2.2 ifdef's - ptb v2.2.17
+ * 99-12-18 further o-o - ptb v2.2.19
+ * 99-12-28 queue account cleanup. endio on queue reqs at reset - ptb v2.2.20
+ *          interruptible semaphores for better client recovery - ptb v2.2.20
+ * 00-1-2   debugging cleanups. Fix race in end_request - ptb v2.2.21
+ * 00-1-4   semaphores simplified. - ptb v2.2.22
+ * 00-6-8   emergency control by write to proc - ptb v2.2.24
+ * 00-7-20  ported to 2.4.0-test1. Possible minor bugs found/fixed - ptb v2.2.24
+ * 00-7-27  changed proc i/f to read_proc from get_info in 2.2/2.4 - ptb v2.2.25
+ * 00-7-30  fixed reads before writes under 2.4 by disabling merge - ptb v2.2.25
+ * 00-7-30  and fixed merge_reqs for 2.4, now that I understand! - ptb v2.2.25
+ * 00-7-30  fixed/introduced possible bug in end_io  for 2.2/2.4 - ptb v2.2.25
+ * 00-7-30 added timeval/zone field in requests and replies - ptb v2.4.0
+ * 00-7-30 fixed hitherto masked bug in read_stat in nbd_client - ptb v2.4.0
+ * 00-7-30 added timeout to net writes in nbd_client - ptb v2.4.0
+ * 00-8-20 display fix for devices over 2GB - ptb v2.4.5
+ * 00-8-23 more 64 bit fixes + error out overrange requests- ptb v2.4.6/2.2.27
+ * 00-8-31 add NBD_ERR ioctl to error out slot request- ptb v2.4.9
+ * 00-8-31 soften NBD_SOFT_RESET so doesn't wreck protocol - ptb v2.4.9
+ * 00-9-1  remove %L's from printfs. Kernel 2.2. doesn't - ptb v2.4.10/2.2.27
+ * 00-9-6  add various state flags to help init order - ptb v2.4.11
+ * 00-9-8  add checks for device initialised to set_sock - ptb v2.4.12
+ * 00-9-17 en/disable device as aslot count goes through 0 - ptb v2.4.13/2.2.28
+ * 00-9-21 split read/write dev req counts for accounting - ptb v2.4.14
+ * 00-9-21 renamed sync_intvl to req_timeo - ptb v2.4.14
+ * 00-9-21 made sync_intvl count write blocks - ptb v2.4.14
+ * 00-9-22 repair enable after delayed disable when disabled - ptb v2.4.14
+ * 00-9-22 include sync (nonblocking) after sync_intvl reqs - ptb v2.4.14
+ * 00-9-25 disable sync (nonblocking) after sync_intvl reqs - ptb v2.4.14
+ * 00-9-25 bundle invalidate_buffers in clr_sock - ptb v2.4.14
+ * 00-10-20 implement req_timeo per device + ioctl (Wang Gang) - ptb v2.4.15
+ * 00-10-20 add raid mode (Wang Gang) - ptb v2.4.15
+ * 00-10-26 throttle in do_req  - ptb v2.4.15
+ * 00-10-28 do set_sock on first open and clr_sock on last close - ptb v2.4.15
+ * 00-11-01 make sync_intvl really sync - ptb v2.4.15
+ * 00-11-14 rename throttle to plug, nbd_sync takes arg - ptb v2.4.17
+ * 00-11-19 clr_sock errs req not rollback if show_errs & !aslot - ptb v2.4.17
+ * 00-11-20 removed autodeadlock when disabled in do_req end_req - ptb v2.4.17
+ * 00-11-21 make MY_NBD_SYNC only sync when sync_intvl > 0 - ptb v2.4.17
+ * 00-12-24 make MY_NBD_GET_REQ use a timeout arg - ptb v2.4.18
+ * 01-02-12 ported to 2.4.0 (works). do_nbd_request rewritten - ptb v2.4.20
+ * 01-02-20 managed to get plugging and clustered read/writes OK - ptb v2.4.21
+ * 01-02-21 eliminated slot->buflen for the time being - ptb v2.4.21
+ * 01-02-27 added proper devfs support - ptb v2.4.22
+ * 01-03-15 allowed more devices/in devfs, cleaned up endio - ptb v2.4.23
+ * 01-03-15 added device letter (<= 3 chars) to struct-  - ptb v2.4.23
+ * 01-03-15 added request size check to do_nbd_req - ptb v2.4.23
+ * 01-03-15 increased MAX_SECTORS to 512 by default - ptb v2.4.23
+ * 01-03-15 made major number a module parameter - ptb v2.4.23
+ * 01-03-18 added max_sectors array - ptb v2.4.23
+ * 01-03-23 added devfs links - ptb v2.4.23
+ * 01-04-17 plugging always enabled for 2.4 kernels - ptb v2.4.24
+ * 01-04-17 made SET_RO set_device_ro as well as set local flags - ptb v2.4.25
+ * 01-04-28 impl SET_MD5SUM ioctl and proc support for md5sum - ptb v2.4.25
+ * 01-04-29 added accounting for md5'd reqs - ptb v2.4.25
+ * 01-07-29 added atomic protections for accounting - ptb v2.4.25
+ * 01-08-01 fixed 2.4 smp bugs. Interrupts off in spinlocks - ptb v2.4.25
+ * 01-08-01 removed all semaphores for spinlocks - ptb v2.4.25
+ * 01-08-01 invalidate_buffers in clr_sock (req'd Rogier Wolff) - ptb v2.4.25
+ * 01-08-02 fixed smp deadlock - end_that_request_first slept! ptb v2.4.26
+ * 01-10-16 provisionally added error in device open when notenabled ptb v2.4.27
+ * 01-10-18 added DIRTY flag to save on repeated invalidate_buffers ptb v2.4.27
+ * 01-10-31 increment seqno_out before delivery, so really starts at 1  v2.4.27
+ * 01-11-01 move zeroing of seqno in cmd field to nbe_end_req* ptb v2.4.27
+ * 01-11-18 add speed calculation, dev fields, display in proc ptb v2.4.27
+ * 01-11-20 modifications for compiling into monolithic kernel ptb v2.4.27
+ * 01-12-06 clr requests before reenabling, not after, in nbd_enable ptb 2.4.27
+ * 02-02-21 make nbd_rollback modal, absirbing nbd_error ptb 2.4.27
+ * 02-08-08 added local BLKSSZGET (reject) and related ioctls ptb 2.4.30
+ * 02-08-12 make nbd_ack not ruin req when its rolled back already ptb 2.4.30
+ * 02-09-18 fix __FUNCTION__ for new gcc ptb 2.4.30
+ * 02-09-18 always allow daemon death even with reqs waiting ptb 2.4.30
+ * 02-09-18 eliminate SYNC_REQD, RLSE_REQD ptb 2.4.30
+ * 02-09-18 eliminate speed_lim ptb 2.4.30
+ * 02-09-18 fix countq accounting ptb 2.4.30
+ * 02-09-18 encapsulate remote ioctl handling ptb 2.4.30
+ * 02-09-18 remote ioctl uses kernel req, not our fake one ptb 2.4.30
+ * 02-09-18 eliminated ctldta use (too much tricky logic) ptb 2.4.30
+ * 02-09-28 handle req specials ptb 2.4.30
+ * 02-10-10 introduce DIRECT flag ptb 2.4.30
+ * 02-10-13 rollback pushes reqs to local queue, not queues them! ptb 2.4.30
+ * 02-10-13 add hooks for separate ioctl module  ptb 2.4.30
+ * 02-10-16 take set_sock out of open. Put pid check in handshake  ptb 2.4.30
+ * 02-10-16 define MY_NBD_GET_NPORT ioctl ptb 2.4.30
+ * 02-10-18 remove wait from MY_NBD_SYNC ioctl ptb 2.4.30
+ * 02-10-20 rollback adds requests to queue in seqno order ptb 2.4.30
+ * 02-10-23 introduce and use pid_sem instead of req_sem ptb 2.4.30
+ * 02-10-30 support client fallback to ioctls on whole disk ptb 2.4.30
+ * 02-11-3  moved set INITIALISED up to coincide with setting inode ptb 2.4.30
+ * 02-11-3  add media check and revalidate routines ptb 2.4.30
+ * 02-11-4  encapuslate lives++ and ENABLED changes into nbd_enable ptb 2.4.30
+ * 02-11-4  set_enable from proc only enables, not clears queue ptb 2.4.30
+ * 11-11-4  take blk_put_request out of end_request (it locks!) ptb 2.4.30
+ * 11-11-4  replace list_del by list_del_init ptb 2.4.30
+ * 02-12-7  nbd_release made aware of daemons on whole disk ptb 2.4.30
+ * 03-01-7  added ioctls for setfaulty etc. ptb 2.4.31
+ * 03-02-1  used metalock for non-queue changes ptb 2.4.31
+ * 03-03-12 add md_list notification ioctls ptb 2.4.31
+ */
+
+#include <linux/major.h>
+#ifndef UNIX98_PTY_MAJOR_COUNT
+  #define UNIX98_PTY_MAJOR_COUNT 8
+  #ifndef UNIX98_NR_MAJORS
+    #define UNIX98_NR_MAJORS=UNIX98_PTY_MAJOR_COUNT
+  #endif
+#endif
+
+#include <linux/module.h>
+
+#if defined(__GNUC__) && __GNUC__ >= 2
+#define _LOOSE_KERNEL_NAMES
+#endif
+
+#include <linux/version.h>
+
+#include <linux/fs.h>
+#include <linux/stat.h>
+#include <linux/errno.h>
+#include <asm/segment.h>
+
+#include <asm/uaccess.h>       /* PTB - when did this arrive in kernel? */
+#include <asm/byteorder.h>
+#include <linux/wrapper.h>
+
+#define MAJOR_NR NBD_MAJOR
+static int major = MAJOR_NR;
+
+#include <linux/proc_fs.h>
+#include <linux/genhd.h>
+#include <linux/hdreg.h>
+
+#include <linux/file.h>                /* PTB - when did this arrive in kernel? */
+
+#include <linux/smp_lock.h>
+
+#include <linux/devfs_fs_kernel.h>
+
+#include <linux/sysctl.h>
+#include <linux/init.h>
+#include <linux/kdev_t.h>
+#include <linux/buffer_head.h>
+#include <linux/completion.h>
+
+/*                                                       *
+ * PTB --------------- compatibility ------------------- *
+ *                   layer starts here.                  *
+ */
+
+  /*
+   * PTB BH_Protected disappeared somewhere around 2.4.10 but this is
+   * still needed for the very rare write local/read remote mode. DOn't
+   * worry about it in normal operation!
+   */
+  #define mark_buffer_protected(rbh) \
+      { \
+       mark_buffer_dirty (rbh); \
+       mark_buffer_uptodate (rbh, 1); \
+       refile_buffer (rbh); \
+       }
+
+  /* PTB list interface extensions */
+  #define list_head(ptr, type, member) \
+  (list_empty(ptr)?NULL:list_entry(((struct list_head *)ptr)->next,type,member))
+  #define list_tail(ptr, type, member) \
+  (list_empty(ptr)?NULL:list_entry(((struct list_head *)ptr)->prev,type,member))
+
+  /* PTB for arches without the atomic mask ops (and no smp, I think!)
+   * - feel free to correct with assembler
+   */
+   #ifndef atomic_set_mask
+     #define atomic_set_mask(mask, x) (x)->counter |= (mask)
+   #endif
+   #ifndef atomic_clear_mask
+     #define atomic_clear_mask(mask, x) (x)->counter &= ~(mask)
+   #endif
+
+/*                                                       *
+ * PTB --------------- compatibility ------------------- *
+ *                   layer ENDS here.                    *
+ */
+
+int linux_version_code = LINUX_VERSION_CODE;
+
+#include <linux/bio.h>
+#include <linux/enbd.h>
+#include <linux/enbd_ioctl.h>
+
+/*
+ * PTB kernel data - 4KB worth
+ * We need space for nda, nda1, .. nda15, ndb, ndb1, ..
+ * The index is exactly the minor number.
+ */
+  static int nbd_blksizes[MAX_NBD * NBD_MAXCONN];
+  static int nbd_sizes[MAX_NBD * NBD_MAXCONN];
+  static __u64 nbd_bytesizes[MAX_NBD * NBD_MAXCONN];
+  static int nbd_max_sectors[MAX_NBD * NBD_MAXCONN];
+
+/*
+ * PTB our data   - about 3KB
+ * These are nda, ndb, ndc, ...
+ * Divide the minor by NBD_MAXCONN to get this index.
+ */
+  static struct nbd_device nbd_dev[MAX_NBD];
+  static spinlock_t nbd_lock = SPIN_LOCK_UNLOCKED;
+  static struct nbd_md nbd_md;
+  static struct nbd_ioctl_stub nbd_remote_ioctl;
+
+  struct nbd_device * nbd_get(int i) {
+      return &nbd_dev[i];
+  }
+
+  #define NBD_FAIL( s ) { \
+    NBD_DEBUG(1, s " (result %d).\n" , result ); \
+    goto error_out; \
+  }
+  #define NBD_HARDFAIL( s ) { \
+    NBD_ERROR( s " (result %d).\n" , result ); \
+    lo->harderror = result; \
+    goto hard_error_out; \
+  }
+
+/*
+ * PTB device parameters. These are module parameters too.
+ */
+
+  static int rahead     = NBD_RAHEAD_DFLT;/* PTB - read ahead blocks  */
+  static int sync_intvl = NBD_SYNC_INTVL; /* PTB - sync every n secs/Kreqs */
+  static int merge_requests               /* PTB - bool, do request coalesce */
+                        = NBD_MERGE_REQ_DFLT;
+  static int buf_sectors = NBD_MAX_SECTORS;
+                                          /* PTB - user bufsize required */
+  static int show_errs = 1;              /* PTB - RAID mode? not usually */
+  static int direct     = 0;              /* PTB - all opens are O_DIRECT  */
+  static int plug = NBD_PLUG_DFLT;
+
+  static int md5sum = 0;                 /* PTB - use md5summing write proto */
+  static int md5_on_threshold = 1000;    /* PTB - reqs reqd to turn md5 on */
+  static int md5_off_threshold = 10;     /* PTB - errs reqd to turn md5 off */
+
+#ifndef NO_BUFFERED_WRITES
+  static int buffer_writes = 0;                  /* PTB - act like ramd on write */
+#endif         /* NO_BUFFERED_WRITES */
+
+#if defined(MODULE)
+  MODULE_PARM (rahead, "i");
+  MODULE_PARM (sync_intvl, "i");
+  MODULE_PARM (merge_requests, "i");
+  MODULE_PARM (buf_sectors, "i");
+  MODULE_PARM (show_errs, "i");
+  MODULE_PARM (direct,"i");
+  #ifndef NO_BUFFERED_WRITES
+    MODULE_PARM (buffer_writes, "i");
+  #endif               /* NO_BUFFERED_WRITES */
+  MODULE_PARM (major, "i");
+  MODULE_PARM (md5sum, "i");
+  MODULE_PARM (md5_on_threshold, "i");
+  MODULE_PARM (md5_off_threshold, "i");
+#endif
+
+  // PTB This pointer is initialised in nbd_init.
+  static struct request_queue * nbd_queue;
+
+#define NO_BUFFERED_WRITES 1
+
+/*                                                       *
+ * PTB --------------- functions ----------------------- *
+ */
+
+/*
+ * PTB 
+ *       Decode the request type of a request and return it. DOn't we
+ *       have anywhere else to put this? Yes, in private data. But
+ *       that's just a pointer to our device data so we don't use it.
+ *
+ *       we use the low bit (REQ_RW) of the flags and the first high bit
+ *       (REQ_NBD) to designate the type of request.
+ *
+ *       @req the request to get the type of.
+ */
+
+static int
+rq_type (struct request *req)
+{
+        if (req->flags & REQ_SPECIAL)
+                return SPECIAL;
+
+        switch ( ((req->flags & REQ_RW) ?1:0)
+               | ((req->flags & REQ_NBD)?2:0)
+               ) {
+            case 0:
+                return READ;
+            case 1:
+                return WRITE;
+            case 2:
+                return IOCTL;
+            case 3:
+                return MD5SUM;
+        }
+        // PTB report what we can of the strangeness if it is strange
+        return (req->flags < 4) ? -1: req->flags;
+}
+
+/*
+ * PTB code the request type into a request.
+ *
+ * This appears to be only used when making an ioctl request and it
+ * never really escapes from our private area and it doesn't matter too
+ * much how efficient it is either.
+ *
+ * This function marks a request for conventional viewing as
+ * being of the designated conceptual type. It correspomds to the old
+ * "type" field in requests.
+ *
+ *  @req the request to set the type on
+ *  @type one of READ, WRITE, etc.
+ */
+static void
+set_rq_type (struct request *req, int type)
+{
+        switch (type) {
+            case READ:
+                req->flags &= ~(REQ_RW | REQ_NBD | REQ_SPECIAL);
+                return;
+            case WRITE:
+                req->flags &= ~(REQ_NBD | REQ_SPECIAL);
+                req->flags |= REQ_RW;
+                return;
+            case IOCTL:
+                req->flags &= ~(REQ_RW | REQ_SPECIAL);
+                req->flags |= REQ_NBD;
+                return;
+            case MD5SUM:
+                req->flags &= ~REQ_SPECIAL;
+                req->flags |= REQ_RW | REQ_NBD;
+                return;
+            case SPECIAL:
+                req->flags |= REQ_RW | REQ_NBD | REQ_SPECIAL;
+                return;
+        }
+}
+
+/*
+ * PTB count number of blocks in a request. This will be an overestimate
+ * if the number is not an exact multiple. It seems to happen. We 
+ * guarrantee to return -ve only if the request is invalid.
+ *
+ * @req - request we want to count
+ */
+inline long
+nr_blks (struct request *req)
+{
+       unsigned log_sectors_per_blk;
+       unsigned sectors_per_blk;
+       int size;
+       int sectors;
+       struct nbd_device *lo;
+
+       if (!req)
+               return -EINVAL;
+
+        if (rq_type(req) == REQ_SPECIAL) // PTB contains no data
+                return 0;
+
+        lo = req->rq_disk->private_data;
+
+       log_sectors_per_blk = lo->logblksize - 9;
+       sectors_per_blk = 1 << log_sectors_per_blk;
+
+       sectors = req->nr_sectors;
+       size = (sectors + sectors_per_blk - 1) >> log_sectors_per_blk;
+
+       return size;
+}
+
+/*
+ * return a temporary buffer containing the (1 or 2 char) device letter.
+ * This works for i up to 26*26. 0 is "a". The buffer is zero
+ * terminated.
+ *
+ *   @i number to be translated to x[y] alphabetical  form.
+ */
+static char *
+device_letter (int i)
+{
+
+       static char buf[3];
+       static int cached_i = -1;
+
+       if (cached_i == i)
+               return buf;
+
+       cached_i = i;
+
+       if (i < 26) {
+               buf[0] = 'a' + i;
+               buf[1] = 0;
+               return buf;
+       }
+
+       buf[0] = 'a' + i / 26;
+       buf[1] = 'a' + i % 26;
+       buf[2] = 0;
+       return buf;
+}
+
+/*
+ * PTB auxiliary functions for manipulating the sequence number. Isn't
+ * there anything private we can use in a request?
+ *
+ * This function returns the sequno
+ *
+ *   @req  the request to get the sequence number of
+ */
+static int
+rq_seqno (struct request *req)
+{
+       return req->flags >> __REQ_NBDSEQNO;
+}
+static void
+rq_set_seqno (struct request *req, int val)
+{
+        // PTB preserve first __REQ_NR_BITS bits
+       req->flags &= REQ_NBDSEQNO - 1;
+        // PTB shift by one more than strictly necessary (see rq_seqno)
+       req->flags |= val << __REQ_NBDSEQNO;
+}
+
+/*
+ *  PTB sync the device. Modes:
+ *  @arg = 1:  Do it sync
+ *  @arg = 0:  Do it async
+ *
+ *  We can't call sync_dev outside a process context. I don't know why.
+ *  Death results from a scheduled attempt.
+ *
+ *  Call without the semaphore held, as we lock it and call sync_dev.
+ */
+static void
+nbd_sync (struct nbd_device *lo, long arg)
+{
+       struct inode *inode = lo->inode;
+       short minor, nbd, islot;
+
+       islot = atomic_read (&lo->islot);
+
+       if (!(atomic_read (&lo->flags) & NBD_INITIALISED) || !inode) {
+               goto fail;
+       }
+
+       minor = minor (inode->i_rdev);
+       nbd = minor >> NBD_SHIFT;
+
+       // PTB sync_dev is async. fsync_dev is sync.
+       switch (arg) {
+         case 0: // async
+               // PTB 2.5.7 does not have async sync!   FIXME
+               break;
+         default: // sync
+               fsync_bdev (inode->i_bdev);
+               invalidate_buffers (mk_kdev (major, nbd << NBD_SHIFT));
+               break;
+       }
+
+       return;
+
+      fail:
+}
+
+static void
+nbd_async_sync (struct nbd_device *lo)
+{
+       nbd_sync (lo, 0);
+}
+static void
+nbd_sync_sync (struct nbd_device *lo)
+{
+       nbd_sync (lo, 1);
+}
+
+/*
+ *  Do sync async if we're enabled, sync if we're not.
+ *
+ *    @lo the device to maybe sync (sync or async sync!)
+ */
+static void
+nbd_maybe_sync_sync (struct nbd_device *lo)
+{
+
+       if ((atomic_read (&lo->flags) & NBD_ENABLED)
+        &&  !(atomic_read (&lo->flags) & NBD_REMOTE_INVALID)) {
+               nbd_async_sync (lo);
+               return;
+       }
+       nbd_sync_sync (lo);
+}
+
+
+
+
+/*
+ * PTB - put a request onto the head of a nbd device's queue
+ *     - presumably having taken it off the kernel's queue first!
+ *     - We take the queue spinlock.
+ *
+ *     @lo      = the device we are on (could we get it from the req?)
+ *     @req     = the request we shift
+ *     @irqsave = save and restore irqmask when taking our queue spinlock
+ */
+static void
+nbd_enqueue (struct nbd_device *lo, struct request *req)
+{
+       unsigned long req_blks = nr_blks (req);
+
+       if (req_blks < 0) {
+               short islot = atomic_read (&lo->islot);
+               NBD_ERROR ("(%d): invalid req %p. Not touching!\n", islot, req);
+               return;
+       }
+
+       /* PTB accounting and nothing more - first, specials */
+        if (! (req->flags & REQ_SPECIAL)) {
+                // PTB the special req counting semantics relies on 
+                // countq not including itself in the count!
+                int countq;
+                int cmd;
+               cmd = rq_data_dir (req);
+               atomic_add (req_blks, &lo->requests_in[cmd]);
+
+                // PTB do we need locks here? Apparently not.
+               atomic_inc (&lo->countq[cmd]);
+                countq = atomic_read (&lo->countq[cmd]);
+
+                // PTB the maxes are just noncritical stats
+               if (atomic_read (&lo->maxq[cmd]) < countq)
+                       atomic_set (&lo->maxq[cmd], countq);
+               atomic_inc (&lo->req_in[cmd][req_blks]);
+                // PTB the maxes are just noncritical stats
+               if (atomic_read (&lo->maxreqblks) < req_blks)
+                       atomic_set (&lo->maxreqblks, req_blks);
+        }
+
+       write_lock (&lo->queue_lock);
+
+        list_add (&req->queuelist, &lo->queue);
+
+       write_unlock (&lo->queue_lock);
+
+       wake_up_interruptible (&lo->wq);
+
+}
+
+/*
+ * PTB - remove a request from anywhere in the nbd device general queue 
+ *     - return 0 for success, -ve for fail
+ *
+ *     We need to hold the queue lock when calling this routine.
+ *     It walks the queue.
+ *
+ *     @lo the nbd device 
+ *     @req the request to be removed
+ */
+static int
+nbd_remove (struct nbd_device *lo, struct request *req)
+{
+       int cmd;
+
+       if (!req)
+               return -EINVAL;
+
+       list_del_init (&req->queuelist);
+
+        /* PTB accounting and nothing more */
+       cmd = rq_data_dir (req);
+        atomic_dec (&lo->countq[cmd]);
+       return 0;
+}
+
+/*
+ *  PTB - Open the device. This is the blkops function.
+ */
+int
+nbd_open (struct inode *inode, struct file *file)
+{
+       int dev;
+       struct nbd_device *lo;
+       int nbd;
+       int part;
+       int islot;
+       char *devnam;
+
+       if (!inode && file) {   /* added by ptb for 2.0.35. Necessary? */
+               inode = file->f_dentry->d_inode;
+       }
+       if (!inode) {
+               NBD_ERROR ("null inode.\n");
+               return -EINVAL;
+       }
+
+       dev = minor (inode->i_rdev);
+       nbd = dev >> NBD_SHIFT;
+       part = dev - (nbd << NBD_SHIFT);
+       islot = part - 1;
+
+       if (nbd >= MAX_NBD) {
+               NBD_ERROR ("too many (%d) whole devices open\n", nbd);
+               return -ENODEV;
+       }
+
+       lo = &nbd_dev[nbd];
+       devnam = lo->devnam;
+
+        /* PTB provision for opening for direct i/o - gives mount aid */
+        if (file
+                && (atomic_read(&lo->flags) & NBD_DIRECT)
+                && !(file->f_flags & O_DIRECT)) {
+                    /* PTB we set NOFOLLOW to show we did it ! */
+                    file->f_flags |= O_DIRECT | O_NOFOLLOW;
+        }
+
+       if (part == 0) {
+               /* PTB we have got the whole dev's file or inode for 1st time */
+               if (!lo->file || lo->file != file) {
+                       lo->file = file;
+                        atomic_set (&(&lo->wspeed)->frstj, jiffies);
+                        atomic_set (&(&lo->rspeed)->frstj, jiffies);
+                        atomic_set (&(&lo->tspeed)->frstj, jiffies);
+               }
+               if (!lo->inode || lo->inode != inode) {
+                       lo->inode = inode;
+               }
+               if (!(atomic_read (&lo->flags) & NBD_INITIALISED)) {
+                       atomic_set_mask (NBD_INITIALISED, &lo->flags);
+               }
+       }
+
+       atomic_inc (&lo->refcnt);
+
+        if (!(atomic_read (&lo->flags) & NBD_VALIDATED)
+            && lo->aslot > 0
+            && (atomic_read (&lo->flags) & NBD_ENABLED)) {
+               NBD_INFO ("partition check on device nd%s\n", lo->devnam);
+                check_disk_change(inode->i_bdev);
+
+                /*
+                 * PTB do we set VALIDATED here, or let the kernel call
+                 * sequence result in it happening via our removable
+                 * device routines? Let's go for the latter option.
+                 */
+        }
+
+       return 0;
+}
+
+/*
+ * PTB - complete a transaction irrefutably by taking it out of the
+ *     - slot pending position it is in, and reporting end_request to kernel
+ *
+ *       We are called without locks because our call to end request
+ *       will take some sort of lock momentarily and we don't need
+ *       locks because our request should already be off all queues.
+ *
+ *       @slot the nbd_slot on which the req notionally was
+ *       @req  the poor defenceless kernel request about to be acked
+ */
+void
+nbd_commit (struct nbd_slot *slot, struct request *req)
+{
+
+       struct nbd_device *lo = slot->lo;
+       unsigned long req_blks = nr_blks (req);
+       int cmd;
+
+       if (req_blks < 0) {
+               NBD_ERROR ("corrupted req %p. Not touching with bargepole.\n",
+                        req);
+               return;
+       }
+
+       list_del_init (&req->queuelist);
+
+       nbd_end_request_lock (req);
+        blk_put_request (req);
+
+       slot->req_age = 0;
+       slot->req -= req_blks;
+
+        /* PTB accounting and nothing more */
+       cmd = rq_data_dir (req);
+
+       atomic_sub (req_blks, &lo->requests_req[cmd]);
+       if (req->errors != 0) {
+                /* PTB error exit */
+               atomic_add (req_blks, &lo->requests_err);
+               slot->err += req_blks;
+               return;
+       }
+
+       atomic_add (req_blks, &lo->requests_out[cmd]);
+       slot->out += req_blks;
+
+       if (cmd != WRITE)
+                /* PTB everything but a write was easy */
+               return;
+
+       /*
+         * PTB now non error case writes
+         *
+        *     account the 4 cases for a md5sum'd transaction
+         */ 
+
+       switch (slot->flags & (NBD_SLOT_MD5SUM | NBD_SLOT_MD5_OK)) {
+
+         case NBD_SLOT_MD5SUM | NBD_SLOT_MD5_OK:
+               atomic_add (req_blks, &lo->wrequests_5to);      // 11
+               atomic_add (req_blks, &lo->wrequests_5so);
+               // PTB zero the countdown to turning off md5 as it works
+               atomic_set (&lo->wrequests_5co, 0);
+               break;
+
+         case NBD_SLOT_MD5SUM:
+               atomic_add (req_blks, &lo->wrequests_5to);      // 10
+               atomic_add (req_blks, &lo->wrequests_5wo);
+               atomic_inc (&lo->wrequests_5co);
+               if (atomic_read (&lo->wrequests_5co) > md5_off_threshold) {
+                       atomic_set (&lo->wrequests_5co, 0);
+                       // PTB turn off md5summing as it is not successful
+                       atomic_clear_mask (NBD_MD5SUM, &lo->flags);
+               }
+               break;
+
+         case NBD_SLOT_MD5_OK:
+               atomic_add (req_blks, &lo->wrequests_5to);      // 01
+               atomic_add (req_blks, &lo->wrequests_5eo);
+               atomic_inc (&lo->wrequests_5co);
+               if (atomic_read (&lo->wrequests_5co) > md5_off_threshold) {
+                       atomic_set (&lo->wrequests_5co, 0);
+                       // PTB turn off md5summing as it is errored
+                       atomic_clear_mask (NBD_MD5SUM, &lo->flags);
+               }
+               break;
+
+         default:
+         case 0:
+               // PTB nobody asked for a md5 and nobdy gave one back
+               atomic_inc (&lo->wrequests_5no);
+               if (atomic_read (&lo->wrequests_5no) > md5_on_threshold) {
+                       atomic_set (&lo->wrequests_5no, 0);
+                       // PTB turn on md5summing every so often
+                       atomic_set_mask (NBD_MD5SUM, &lo->flags);
+               }
+               break;
+       }
+
+       // PTB clear the md5sum indicators from the slot afterwards!
+       slot->flags &= ~(NBD_SLOT_MD5SUM | NBD_SLOT_MD5_OK);
+
+        // PTB we ran out of difficult cases, so return
+}
+
+/*
+ * PTB - error out a transaction irrefutably by taking it out of the
+ *     - slot pending position it is in, and reporting end_request to kernel
+ *
+ *     We must be called without spinlocks held, as we take it in end req
+ *
+ *       @slot the nbd_slot on which the req notionally was
+ *       @req  the poor defenceless kernel request about to be errored
+ */
+void
+nbd_error (struct nbd_slot *slot, struct request *req)
+{
+       struct nbd_device *lo = slot->lo;
+       unsigned long req_blks = nr_blks (req);
+       int cmd;
+
+       if (req_blks < 0) {
+               NBD_ERROR ("passed illegal request %p\n", req);
+       }
+
+       req->errors++;
+
+       /*
+         * PTB We don't need the queue spinlock since we don't touch our queue,
+        * and we're the only ones working on this slot.
+         */
+       list_del_init (&req->queuelist);
+
+       NBD_ALERT ("error out req %p from slot %d!\n", req, slot->i);
+
+       nbd_end_request_lock (req);
+        blk_put_request (req);
+
+       /* PTB accounting and nothing more */
+       cmd = rq_data_dir (req);
+       atomic_sub (req_blks, &lo->requests_req[cmd]);
+
+       slot->in -= req_blks;
+       slot->req -= req_blks;
+
+       slot->req_age = 0;
+       slot->err += req_blks;
+       atomic_add (req_blks, &lo->requests_err);
+}
+
+/*
+ * Take a request out of a slot. This must not hold the queuelock on
+ * entry as we take the queue lock in order to play with the devices
+ * queue.
+ *
+ *  @slot the nbd slot on which to work
+ *  @req the request
+ */
+static void
+nbd_rollback (struct nbd_slot *slot, struct request *req)
+{
+
+       struct nbd_device *lo = slot->lo;
+       unsigned long req_blks, flags;
+       int seqno;
+        struct list_head *pos;
+        struct request *xreq;
+
+       if (atomic_read (&lo->flags) & NBD_SHOW_ERRS) {
+               nbd_error (slot, req);
+               return;
+       }
+
+       req_blks = nr_blks (req);
+
+       if (req_blks < 0) {
+               NBD_ERROR ("passed illegal request %p\n", req);
+               return;
+       }
+
+       list_del_init (&req->queuelist);
+
+       NBD_ALERT ("rollback req %p from slot %d!\n", req, slot->i);
+
+        if (! (req->flags & REQ_SPECIAL)) {
+               /* PTB accounting */
+               slot->in -= req_blks;
+               slot->req -= req_blks;
+        }
+
+        seqno = rq_seqno(req);
+
+        write_lock_irqsave(&lo->queue_lock, flags);
+        list_for_each_prev (pos, &lo->queue) {
+                xreq = list_entry (pos, struct request, queuelist);
+                if (rq_seqno(xreq) > seqno) {
+                        break;
+                }
+        }
+        list_add_tail (&req->queuelist, pos);
+        write_unlock_irqrestore(&lo->queue_lock, flags);
+
+}
+
+/*
+ * PTB - undo transactions by taking them out of the slot pending
+ *     - position and replacing them on the generic device queue
+ *     - NB we do not hold the io request lock or queue sem when
+ *     -    calling this as we take it internall in nbd_rollback
+ *
+ *     @slot the nbd slot to scan
+ */
+static void
+nbd_rollback_all (struct nbd_slot *slot)
+{
+
+       struct request *req;
+       short count = 0;
+
+       while (!list_empty (&slot->queue)) {
+
+               if (count++ > 1000)
+                       break;
+
+               req = list_head (&slot->queue, struct request, queuelist);
+
+               if (!req)
+                       break;
+
+               nbd_rollback (slot, req);
+       }
+
+}
+
+/*
+ * PTB error out all the requests on a slot
+ *     
+ *     We must be called without the io spinlock held, as we take it in
+ *     nbd_error().
+ *
+ *     @slot the nbd slot to scan
+ */
+static void
+nbd_error_all (struct nbd_slot *slot)
+{
+
+       struct request *req;
+       short count = 0;
+
+       while (!list_empty (&slot->queue)) {
+               if (count++ > 1000)
+                       break;
+               req = list_head (&slot->queue, struct request, queuelist);
+               if (!req)
+                       break;
+               nbd_error (slot, req);
+       }
+}
+
+/*
+ * PTB - let a request onto the slot pending position
+ *     - Can be called without the spinlock and doesn't take the
+ *       spinlock as we  only deal with our  unique slot. If there
+ *       were more than one client per slot this woould be a problem
+ *       but there aren't so it isn't.
+ *
+ *       @slot the nbd slot to let the request onto
+ *       @req the request to move onto the slot queue
+ */
+void
+nbd_accept (struct nbd_slot *slot, struct request *req)
+{
+
+       struct nbd_device *lo = slot->lo;
+       unsigned long req_blks = nr_blks (req);
+       int cmd;
+
+       if (req_blks < 0)
+               return;
+
+        /* PTB accounting and nothing more */
+       cmd = rq_data_dir (req);
+
+       atomic_add (req_blks, &lo->requests_req[cmd]);
+       /* PTB - Note that this really is slot and not lo.
+        */
+       list_add (&req->queuelist, &slot->queue);
+
+       slot->req_age = jiffies;
+       slot->in += req_blks;
+       slot->req += req_blks;
+}
+
+/*
+ * PTB - read from userspace to a request buffer. Do it piecewuse
+ *     - to cope with clustered requests.
+ *     - return number of bytes read
+ *
+ *     Unfortunately the only way we can return less than the right
+ *     number of bytes is when the receiving req does not have the
+ *     right number of buffers, because the copy_from_user itself
+ *     doesn't tell us.
+ */
+static int
+copy_from_user_to_req (struct request *req, char *user, int len)
+{
+
+       unsigned size = 0;
+        struct bio *bio /* = req->bio */;
+
+       /* PTB assume user verified */
+
+        rq_for_each_bio(bio, req) {
+
+            int i;
+            struct bio_vec * bvl;
+
+            bio_for_each_segment(bvl, bio, i) {
+
+                struct page *page       = bvl->bv_page;
+                int offset              = bvl->bv_offset;
+                const unsigned current_size
+                                    = bvl->bv_len;
+               char *buffer;
+                buffer = page_address(page) + offset;
+ 
+               copy_from_user (buffer, user + size, current_size);
+
+               size += current_size;
+           }
+       }
+       if (size != len) {
+               NBD_ALERT ("requested %d and only read %d bytes to req %p\n",
+                 len, size, req);
+               NBD_ALERT ("request %p wanted to read user space buffer %p\n",
+                 req, user);
+       }
+       return size;
+}
+
+/*
+ * PTB - andres' kernel half of the user-space network handshake, used
+ *     - to complete a transaction.
+ *     - return 0 for success and -ve for fail.
+ *
+ *     @slot the nbd slot being acted on
+ *
+ */
+int
+nbd_ack (struct nbd_slot *slot)
+{
+       struct nbd_reply reply;
+       struct request *req, *xreq;
+       int result = 0;
+
+       void *user;
+       unsigned long req_blks = 1;
+       struct nbd_device *lo = slot->lo;
+       unsigned buflen = 0;
+       unsigned reqlen;
+        int cmd;
+       struct list_head *pos;
+       int count = 0;
+
+       if (!(slot->flags & NBD_SLOT_BUFFERED)) {
+               return -EINVAL;
+       }
+
+       atomic_inc (&lo->cthreads);
+       slot->flags |= NBD_SLOT_RUNNING;
+       slot->cli_age = jiffies;
+
+       user = slot->buffer;
+       copy_from_user ((char *) &reply, (char *) user,
+                       sizeof (struct nbd_reply));
+
+       // PTB we keep tracking the write position in the input buffer
+       buflen += NBD_BUFFER_DATA_OFFSET;
+
+       // PTB save the reply handle (which is an address) as our req
+       memcpy (&req, &reply.handle, sizeof (req));
+
+       xreq = NULL;
+       list_for_each (pos, &slot->queue) {
+               xreq = list_entry (pos, struct request, queuelist);
+               if (count++ > 1000)
+                       break;
+               if (xreq == req)
+                       /* PTB found it */
+                       break;
+       }
+
+       if (xreq != req) {
+
+               if (slot->nerrs++ < 3)
+                       NBD_ALERT ("fatal: Bad handle %p != %p!\n",
+                         req, xreq);
+
+                atomic_dec (&lo->cthreads);
+                slot->flags &= ~NBD_SLOT_RUNNING;
+
+                NBD_ALERT("ignoring ack of req %p which slot does not have\n", 
+                    req);
+
+                /*
+                 * PTB we lie and say success because userspace got through to
+                 * us OK and the req they missed has been rolled back and will
+                 * be retransmitted by the kernel later and elsewhere
+                 */
+                return 0;
+       }
+
+       if (reply.magic != NBD_REPLY_MAGIC) {
+
+               if (slot->nerrs++ < 3)
+                       NBD_ALERT ("Not enough reply magic in %s\n",
+                                  __FUNCTION__ );
+                /*
+                 * PTB returning -EAGAIN causes the client to pause 0.5s 
+                 * and throw its reply away, then return to service. We leave
+                 * any request we have to age and be rolled back.
+                 */
+               return -EAGAIN;
+       }
+
+       if (reply.error > 0 || req->errors > 0) {
+               /* PTB wasn't error++'ed before */
+               req->errors++;
+               if (slot->nerrs++ < 3)
+                       NBD_ALERT ("exited with reply error\n");
+               /* PTB we handle this - it's a repmote error */
+                NBD_FAIL ("remote error on request\n");
+       }
+
+       req_blks = nr_blks (req);
+
+       reqlen = req->nr_sectors;
+       reqlen <<= 9;
+
+       cmd = rq_type (req);
+
+        switch (cmd) {
+
+                unsigned long rcmd;
+                char * arg;
+               int size;
+
+         case READ:
+
+               // PTB We have to copy the buffer bit by bit in
+               // case the request is clustered.
+
+               size =
+                copy_from_user_to_req (req, ((char *) user) + buflen, reqlen);
+               if (size < reqlen) {
+                       NBD_ALERT
+                        ("(%d): copy %dB from user to req %p failed (%d)\n",
+                         slot->i, reqlen, req, size);
+                       // PTB we could try again? We should investigate.
+                       NBD_FAIL
+                        ("exited because of bad copy from user\n");
+                        // PTB FIXME - think we want to discard and retry
+               }
+
+               // PTB we keep tracking the write position in the buffer
+               buflen += size;
+               break;
+
+         case WRITE:
+               /*
+                 * PTB we want to know if the reply is md5summed, and if it is
+                *     whether the md5sum is the same as the one on the
+                *     request. But that's not something we can presently see
+                *     from here as we don't make an md5sum in the kernel.
+                *     So we have to rely on the reply flag from userspace.
+                *     We transmit the information to the slot, as we can't
+                *     keep it on the request.
+                 */
+
+               switch (reply.flags &
+                       (NBD_REPLY_MD5SUM | NBD_REPLY_MD5_OK)) {
+
+                 case NBD_REPLY_MD5SUM | NBD_REPLY_MD5_OK:
+                       /*
+                         * PTB we asked for an md5sum comparison and
+                        * the two matched, so we skipped writing the request
+                         */
+                       slot->flags |= (NBD_SLOT_MD5SUM | NBD_SLOT_MD5_OK); //11
+                       break;
+                 case NBD_REPLY_MD5SUM:
+                       // PTB the two differed, so we wrote the request
+                       slot->flags |= NBD_SLOT_MD5SUM;
+                       slot->flags &= ~NBD_SLOT_MD5_OK;        // 10
+                       break;
+                 case NBD_REPLY_MD5_OK:
+                       // PTB the server refused the md5 request
+                       slot->flags &= ~NBD_SLOT_MD5SUM;
+                       slot->flags |= NBD_SLOT_MD5_OK;         // 01
+                       break;
+                 default:
+                 case 0:
+                       // PTB mobody asked for an md5sum comparison
+                       slot->flags &= ~(NBD_SLOT_MD5SUM | NBD_SLOT_MD5_OK);//00
+                       break;
+               }
+               // PTB now we are all set up to do the accounting in commit etc.
+               break;
+
+          case SPECIAL:
+                // PTB FIXME. Just temporary. 
+               NBD_ALERT ("special req %p on slot %d\n", req, slot->i);
+                req->errors = 0;
+                goto success;
+               break;
+
+
+         case IOCTL:
+
+               if (!(reply.flags & NBD_REPLY_IOCTL))
+                       NBD_ALERT ("ioctl reply to req %p has no ioctl flag\n",
+                                req);
+
+               // PTB the commit should emit the request notification
+
+               rcmd = (long) req->special;
+               arg = req->buffer;
+
+               if (cmd == -1l) {
+                       result = -EINVAL;
+                       NBD_FAIL ("unauthorized remote ioctl\n");
+               }
+
+               if (!(_IOC_DIR (cmd) & _IOC_READ)) {
+                        break;
+                }
+
+               /*
+                 * PTB We saved ioctl size in req .. but only approximately,
+                 * as nr_sectors.
+                 */
+
+               /*
+                 * PTB if we are reading, it should be to the local
+                 * buffer arg, which points at lo->ctldata or other buffer
+                 */
+
+                // PTB we are treating a saved local address or direct val
+               if (req->nr_sectors > 0) {
+                       /*
+                         * PTB sectors is an overestimate.  Should be
+                         * OK as we are reading from the client
+                         * buffer which has plenty of room to spare.
+                         */
+                       int size = req->nr_sectors << 9;
+                       copy_from_user (arg, (char *) user + buflen, size);
+                       buflen += size;
+                        break;
+               }
+
+               break;
+       }                       // PTB eswitch
+        goto success;
+
+      success:
+       slot->nerrs = 0;
+       /*
+         * PTB - completion (or erroring) of transaction.
+        * note that nbd_commit will take a lock to do end_req
+         */
+       nbd_commit (slot, req);
+       atomic_dec (&lo->cthreads);
+       slot->flags &= ~NBD_SLOT_RUNNING;
+       return 0;
+
+      error_out:
+       /* PTB we will next do a client rollback on the slot from userspace.
+        *     Right here we just skip the request. 
+         *     But .. don't error the request. We might have rolled it
+         * back and be referencing it.
+         */
+        if (result != -EAGAIN && result != 0) {
+               req->errors += req_blks;
+               slot->err += req_blks;
+        }
+       result = result < 0 ? result : -ENODEV;
+        // PTB one client thread leaves
+       atomic_dec (&lo->cthreads);
+       slot->flags &= ~NBD_SLOT_RUNNING;
+       return result;
+}
+
+/*
+ * PTB - write to userspace from a request buffer. Do it piecewuse
+ *     - to cope with clustered requests.
+ *     - return number of bytes written
+ */
+static int
+copy_to_user_from_req (struct request *req, char *user, int len)
+{
+
+       unsigned size = 0;
+        struct bio *bio /* = req->bio */;
+
+       /* PTB assume user verified */
+
+        rq_for_each_bio(bio, req) {
+
+            int i;
+            struct bio_vec * bvl;
+
+            bio_for_each_segment(bvl, bio, i) {
+
+                struct page *page       = bvl->bv_page;
+                int offset              = bvl->bv_offset;
+                const unsigned current_size
+                                        = bvl->bv_len;
+               char *buffer;
+                buffer = page_address(page) + offset;
+ 
+               copy_to_user (user + size, buffer, current_size);
+
+               size += current_size;
+            }
+
+       }
+       return size;
+}
+
+/*
+ * PTB do the devices three speed updates
+ *
+ *  @lo  the nbd device to do the update on
+ */
+static void
+nbd_set_speed (struct nbd_device *lo)
+{
+        int r, w, t;
+        struct nbd_speed *wspd = &lo->wspeed;
+        struct nbd_speed *rspd = &lo->rspeed;
+        struct nbd_speed *tspd = &lo->tspeed;
+       w = atomic_read (&lo->requests_in[WRITE]);
+       wspd->update (wspd, w);
+       r = atomic_read (&lo->requests_in[READ]);
+       rspd->update (rspd, r);
+        t = w + r;
+       tspd->update (tspd, t);
+}
+
+
+
+/*
+ * PTB - andres' kernel half of the userspace networking. This part
+ *     - initiates the transaction by taking a request off the generic
+ *     - device queue and placing it in the slots pending position.
+ *     - I believe we return 0 for success and -ve for fail.
+ *     - timeo is the number of jiffies we are prepared to wait
+ *
+ *     @slot the nbd slot to act on.
+ */
+int
+nbd_get_req (struct nbd_slot *slot)
+{
+       struct nbd_request request;
+       struct request *req;
+       int result = 0;
+       static atomic_t count;
+       unsigned start_time = jiffies;
+       struct nbd_device *lo = slot->lo;
+       unsigned timeout = lo->req_timeo * HZ;
+       int islot = slot->i;
+       // PTB for the new timezone field in requests 
+       extern struct timezone sys_tz;
+        struct timeval time;
+       unsigned long flags;
+        struct nbd_seqno * seqno_out = &lo->seqno_out;
+
+       atomic_inc (&lo->cthreads);     // PTB - client thread enters
+       slot->flags |= NBD_SLOT_RUNNING;
+       slot->cli_age = jiffies;
+
+       if (!(slot->flags & NBD_SLOT_BUFFERED)) {
+               NBD_FAIL ("Our slot has no buffer");
+       }
+
+       atomic_set (&lo->islot, islot);
+
+       if (!list_empty (&slot->queue)) {
+               NBD_FAIL ("impossible! already treating one request");
+               // PTB we do a nontrivial rollback from the user daemon 
+       }
+       if (!slot->file) {
+               result = -EBADF;
+               NBD_FAIL ("Our slot has been nofiled");
+       }
+       if (!(atomic_read (&lo->flags) & NBD_ENABLED)) {
+               result = -ENODEV;
+               NBD_FAIL ("Our slot has been vamooshed");
+       }
+
+       atomic_inc (&lo->cwaiters);
+       slot->flags |= NBD_SLOT_WAITING;
+
+       // PTB take spinlock in order to examine queue
+       // we need to protect ourselves against the request fn too
+       read_lock_irqsave (&lo->queue_lock, flags);
+       atomic_dec (&lo->cwaiters);
+       slot->flags &= ~NBD_SLOT_WAITING;
+
+       // PTB - now spin until request arrives to treat 
+       while (slot->file && list_empty (&lo->queue)) {
+
+               static int nbd_clr_sock (struct nbd_slot *slot); // forward decl
+               int siz;
+                int time_left = start_time + timeout - jiffies;
+
+               read_unlock_irqrestore (&lo->queue_lock, flags);
+
+                // PTB one client thread goes to sleep
+               atomic_inc (&lo->cwaiters);
+               slot->flags |= NBD_SLOT_WAITING;
+
+               interruptible_sleep_on_timeout (&lo->wq, time_left);
+
+               slot->flags &= ~NBD_SLOT_WAITING;
+                // PTB one client thread reactivates
+               atomic_dec (&lo->cwaiters);
+               atomic_inc (&count);
+
+               // PTB Have to take the spinlock again to check at the queue
+               atomic_inc (&lo->cwaiters);
+               slot->flags |= NBD_SLOT_WAITING;
+               // we need to protect ourselves against the request fn too
+               read_lock_irqsave (&lo->queue_lock, flags);
+               atomic_dec (&lo->cwaiters);
+               slot->flags &= ~NBD_SLOT_WAITING;
+
+               // PTB fail for recheck if we are inactive too long 
+
+                time_left = start_time + timeout - jiffies;
+               if (time_left > 0 || !list_empty (&lo->queue))
+                        continue;
+
+                // PTB bad. timeout with nothing on queue. Error out.
+               result = -ETIME;
+
+               // PTB we will exit with fail, so up spinlock now
+               read_unlock_irqrestore (&lo->queue_lock, flags);
+
+               siz = lo->blksize + sizeof (struct nbd_request);
+               // PTB verify the buffer is still OK - holds one block 
+               if (access_ok(VERIFY_WRITE,slot->buffer,siz))
+                        goto error_out;
+
+                // PTB buffer is invalid
+               result = -EINVAL;
+
+               // PTB clr_sock takes both the io lock and the spinlock
+               nbd_clr_sock (slot);
+               NBD_FAIL ("Our process has died or lost its buffer");
+
+               /*
+                 * PTB we may do a rollback from the user daemon here
+                * but it'll be trivial - without effect - as we don't
+                * have a request in our slot to treat.
+                 */
+               goto error_out;
+
+       } // end while loop
+
+       // PTB we still have the (read) spinlock here
+
+       if (!(atomic_read (&lo->flags) & NBD_ENABLED)) {
+               read_unlock_irqrestore (&lo->queue_lock, flags);
+               result = -ENODEV;
+               NBD_FAIL ("Our slot vaporized while we slept!");
+       }
+       if (!slot->file) {
+               read_unlock_irqrestore (&lo->queue_lock, flags);
+               result = -EBADF;
+               NBD_FAIL ("Our slot nofiled itself while we slept!");
+       }
+       if (!list_empty (&slot->queue)) {
+               read_unlock_irqrestore (&lo->queue_lock, flags);
+               result = -EINVAL;
+               NBD_FAIL ("impossible! already treating one request");
+               // PTB we do a nontrivial rollback from the user daemon 
+       }
+
+       // PTB now relinquish the read lock and try for the write lock
+       read_unlock_irqrestore (&lo->queue_lock, flags);
+
+       write_lock_irqsave (&lo->queue_lock, flags);
+       // PTB got the write lock
+
+       if (list_empty (&lo->queue)) {
+               write_unlock_irqrestore (&lo->queue_lock, flags);
+               // PTB - somebody else did it while we waited on spinlock. OK 
+               result = -EINVAL;
+               NBD_FAIL ("ho hum beaten to the punch");
+               // PTB we may do a trivial rollback from the user daemon 
+       }
+
+       // PTB cli/sti here looks unnec. hardware interrupts return here 
+       // AMARIN begin uninterruptible code 
+
+       // PTB we have the (write) spinlock
+
+       // PTB oldest=last element in queue 
+       req = list_tail (&lo->queue, struct request, queuelist);
+
+       // PTB this is where we free the req from our queue. We need to be
+       // holding our spinlock at this point
+
+       // PTB - must succeed as have the spinlock 
+       result = nbd_remove (lo, req);
+       // PTB now holding irqs off in nbd_remove 
+
+       // AMARIN end uninterruptable code 
+       // PTB uh - maybe cli/sti is needed? interrupts can muck the queue?
+       //        - Nah! I have left them enabled so we can see any errors.
+
+       write_unlock_irqrestore (&lo->queue_lock, flags);
+
+       request.magic = NBD_REQUEST_MAGIC;
+       request.flags = 0;
+
+       switch (rq_type (req)) {
+
+               unsigned long cmd;
+               char *arg;
+               size_t size;
+
+         case IOCTL:
+
+               request.type = IOCTL;
+
+               // PTB this is our special ioctl kernel request
+
+               cmd = (unsigned long) req->special;
+               arg = req->buffer;
+               size = req->nr_sectors << 9;
+
+               // PTB the arg was a literal
+
+               request.len = 0;
+               // PTB we are in get_req, transferring stored ioctl
+               if ((_IOC_DIR (cmd) & _IOC_READ) && size > 0) {
+                       // PTB if len is +ve we copy to the user buffer later
+                        request.len = size;
+               } 
+               // PTB we store the weirded ioctl id.
+               // PTB Yes, this composition is our private invention.
+               request.from = (((__u64) cmd) << 32)
+                    // PTB really want this to go to a 64 bit request.special
+                    | ((__u64) (unsigned long) arg);
+               break;
+
+         case READ:
+         case WRITE:
+
+               request.type = rq_data_dir (req);
+               request.from = req->sector;
+               request.from <<= 9;
+               request.len = req->nr_sectors;
+               request.len <<= 9;
+               if (atomic_read (&lo->flags) & NBD_MD5SUM) {
+                       // PTB set the please do md5sum flag on the request
+                       request.flags |= NBD_REQUEST_MD5SUM;
+               }
+               break;
+
+          case MD5SUM:
+                break;
+
+          case SPECIAL:
+               request.type = SPECIAL;
+               request.len = req->nr_sectors;
+               request.len <<= 9;
+               request.from = req->sector;
+               request.from <<= 9;
+                if (rq_data_dir (req) == WRITE)
+                        request.flags |= NBD_REQUEST_SPECIALRW;
+                request.special = (typeof(request.special))req->special;
+                break;
+
+         default:
+               NBD_ALERT ("received unknown req %p type %#x\n",
+                          req, rq_type (req));
+               break;
+       }
+
+       request.seqno = seqno_out->calc(seqno_out, rq_seqno (req));
+
+       /*
+         * PTB we should here erase the extra seqno info in the request
+         * so that on error or on ack the kernel can use the right internal
+         * array, but I'll erase it in the ack function instead
+         */
+
+       do_gettimeofday (&time);
+        request.time = time.tv_sec;
+        request.time *= 1000000;
+        request.time += time.tv_usec;
+        request.zone = sys_tz.tz_minuteswest;
+
+       // PTB tz_dsttime = 0 always in linux
+
+       memcpy (&request.handle, &req, sizeof (request.handle));
+
+       copy_to_user (slot->buffer, (char *) &request, sizeof (request));
+
+       switch (request.type) {
+
+               int err;
+                char * arg;
+
+         case READ:
+               break;
+
+         case IOCTL:
+               if (request.len <= 0)
+                        break; // PTB presumably nothing to do
+               arg = (char *) slot->buffer + NBD_BUFFER_DATA_OFFSET;
+               copy_to_user (arg, req->buffer, request.len);
+               break;
+
+         case WRITE:
+               arg = (char *) slot->buffer + NBD_BUFFER_DATA_OFFSET;
+               err = copy_to_user_from_req (req, arg, request.len);
+               if (err >= request.len)
+                        break; // OK
+               // PTB buffer had missing BHSs
+               NBD_ERROR ("req %p offered %d bytes of %d for copy to user\n",
+                       req, result, request.len);
+               // PTB this request is badly damaged. We had better shoot it.
+               if (req && req->errors == 0) {
+                       req->errors++;
+                       nbd_end_request_lock (req);
+                        blk_put_request (req);
+               }
+               NBD_FAIL ("kernel failed to keep req while we copied from it");
+               break;
+          case MD5SUM:
+                break;
+          case SPECIAL:
+                // PTB temporary. We do not treat specials at the moment.
+               req->errors = 0;
+                break;
+          default:
+               NBD_ERROR ("req %p was type %#x\n", req, rq_type(req));
+               NBD_FAIL ("unknown req type");
+                break;
+       }
+
+       /*
+         * PTB nbd_accept does not take spinlock and does not need to as
+        * the req is already free of the shared queue and only needs
+        * to be placed on the unique slot queue.
+         */
+
+       nbd_accept (slot, req);
+
+       atomic_dec (&lo->cthreads);     // PTB - client thread leaves normally 
+       slot->flags &= ~NBD_SLOT_RUNNING;
+
+       return 0;
+
+      error_out:
+       // PTB accounting - a fail to get a request is not an errored request 
+       atomic_dec (&lo->cthreads);     // PTB - client thread leaves abnormally 
+       slot->flags &= ~NBD_SLOT_RUNNING;
+       result = result < 0 ? result : -ENODEV;
+
+       return result;
+}
+
+/*
+ * PTB error out the pending requests on the kernel queue
+ * We have to be called WITHOUT the io request lock held.
+ * We sleep imbetween clearing each request, for "safety".
+ *
+ *   @lo the nbd device to scan
+ */
+static int
+nbd_clr_kernel_queue (struct nbd_device *lo)
+{
+
+       int count = 0;
+       unsigned long flags;
+        request_queue_t *q = lo->q;
+
+       spin_lock_irqsave (q->queue_lock, flags);
+
+       while (! blk_queue_empty(q) && count++ < 1000) {
+               struct request *req;
+                req = elv_next_request(q);
+               if (!req) {     // PTB impossible
+                       spin_unlock_irqrestore (q->queue_lock, flags);
+                       NBD_ALERT
+                        ("impossible! kernel queue empty after tested nonemty!\n");
+                       goto fail;
+               }
+               blkdev_dequeue_request (req);
+               spin_unlock_irqrestore (q->queue_lock, flags);
+                if (!req->errors)
+                       req->errors++;
+               schedule ();
+               nbd_end_request_lock (req);
+                blk_put_request (req);
+               spin_lock_irqsave (q->queue_lock, flags);
+       }
+       spin_unlock_irqrestore (q->queue_lock, flags);
+       goto success;
+
+      fail:
+       /* PTB fall thru */
+      success:
+       NBD_ALERT ("removed %d requests\n", count);
+       return count;
+
+}
+
+/*
+ * PTB error out the pending requests on the nbd queue and kernel queue
+ * Note that we take the queue spinlock for this
+ *
+ *   @lo the nbd device to scan
+ */
+static int
+nbd_clr_queue (struct nbd_device *lo)
+{
+       int count = 0;
+
+       while (count < 1000) {
+
+               struct request *req;
+               unsigned long req_blks = 1;
+
+                // PTB cannot allow new requests via interrupts
+               write_lock (&lo->queue_lock);
+               if (list_empty (&lo->queue)) {
+                       write_unlock(&lo->queue_lock);
+                       break;
+               }
+               req = list_head (&lo->queue, struct request, queuelist);
+                if (!req) {
+                       write_unlock(&lo->queue_lock);
+                       break;
+                }
+
+               req_blks = nr_blks (req);
+
+               req->errors += req_blks + 1;
+               atomic_add (req_blks, &lo->requests_err);
+
+               /* PTB - must succeed as have the spinlock */
+               nbd_remove (lo, req);
+               /* PTB now hold irqs off in nbd_remove */
+               write_unlock(&lo->queue_lock);
+               count++;
+
+               nbd_end_request_lock (req);
+                blk_put_request (req);
+
+       }
+       NBD_ALERT ("unqueued %d reqs\n", count);
+       return count;
+}
+
+/*
+ * PTB do under alt spinlock - we take the lo queue_lock oursekves.
+ * We take all requests off the alt queue to which they've been
+ * diverted and put them on the devices normal queue, where they will
+ * then be treated in the normal course of events. They were diverted
+ * to the alt queue after we received a SPECIAL, and they're being
+ * released now that we've treated all the extant reqs.
+ *
+ *   @lo the nbd device being treated
+ */ 
+static int
+nbd_requeue (struct nbd_device *lo)
+{
+       int count = 0;
+
+       while (count < 1000) {
+
+               struct request *req;
+
+               // PTB cannot allow new requests via interrupts
+               if (list_empty (&lo->altqueue)) {
+                       break;
+               }
+               req = list_tail (&lo->altqueue, struct request, queuelist);
+               if (!req)
+                       break;
+
+               // PTB heisenbug? without these list_del oopses on null deref
+               if (req->queuelist.prev == NULL) {
+                       NBD_ALERT ("req %p has 0 prev ptr! Abort\n", req);
+                       break;
+               }
+               if (req->queuelist.next == NULL) {
+                       NBD_ALERT ("req %p has 0 next ptr! Abort\n", req);
+                       break;
+               }
+               /* PTB - must succeed as have the spinlock */
+               list_del_init (&req->queuelist);
+               /* PTB now hold irqs off in nbd_remove */
+               count++;
+
+               nbd_enqueue (lo, req);
+
+       }
+       return count;
+}
+
+
+#undef NBD_FAIL
+#define NBD_FAIL( s... ) { \
+  NBD_ERROR( s); printk("\n"); \
+  goto error_out; \
+}
+
+#ifndef NO_BUFFERED_WRITES
+  /*
+   * Magic function from rd.c that we hope saves a buffer head
+   * permanently somewhere in the kernel VM system.
+   */
+static int
+buffered_write_pagecache_IO (struct buffer_head *sbh, int nbd)
+{
+       struct address_space *mapping;
+       unsigned long index;
+       int offset, size, err;
+       struct nbd_device *lo = &nbd_dev[nbd];
+       err = 0;
+
+       // PTB we need to save the /dev/nda inode
+       if (!lo->inode) {
+               err = -ENODEV;
+               goto out;
+       }
+       mapping = lo->inode->i_mapping;
+
+       // PTB index appears to be the page number
+       index = sbh->b_rsector >> (PAGE_CACHE_SHIFT - 9);
+       // PTB offset is in bytes, and says where in the page the sector starts
+       offset = (sbh->b_rsector << 9) & ~PAGE_CACHE_MASK;
+       // PTB well, an abbreviation for the buffer size, in bytes
+       size = sbh->b_size;
+
+       do {
+               // PTB we mark each page that we should write to Uptodate
+
+               int count;
+               struct page **hash;
+               struct page *page;
+               char *src, *dst;
+
+               int unlock = 0;
+
+               // PTB ummm, how much of the page is left to traverse
+               count = PAGE_CACHE_SIZE - offset;
+               // PTB reduce it to how much we actually need to traverse
+               if (count > size)
+                       count = size;
+               // PTB say NOW? that we have traversed what we want of the page
+               size -= count;
+
+               hash = page_hash (mapping, index);
+               page = __find_get_page (mapping, index, hash);
+
+               if (!page) {
+                       // PTB we get to make a new page
+                       page = grab_cache_page (mapping, index);
+                       if (!page) {
+                               // PTB failed to get new page
+                               err = -ENOMEM;
+                               goto out;
+                       }
+                       // PTB magic
+                       if (!Page_Uptodate (page)) {
+                               memset (kmap (page), 0, PAGE_CACHE_SIZE);
+                               kunmap (page);
+                               SetPageUptodate (page);
+                       }
+                       // PTB the new page is locked. We need to unlock it later
+                       unlock = 1;
+               }
+
+               // PTB prepare already for next page
+               index++;
+
+               // PTB set up for copy
+               dst = kmap (page);
+               dst += offset;
+               src = bh_kmap (sbh);
+
+               // PTB prepare for next round
+               offset = 0;
+
+               // PTB do a copy
+               memcpy (dst, src, count);
+
+               kunmap (page);
+               bh_kunmap (sbh);
+
+               if (unlock) {
+                       UnlockPage (page);
+               }
+               SetPageDirty (page);
+               __free_page (page);
+
+       } while (size > 0);
+
+      out:
+       return err;
+
+}
+static int
+buffered_write (struct request *req)
+{
+
+       struct buffer_head *bh;
+       int dev = minor (req->rq_dev);
+       int nbd = dev >> NBD_SHIFT;
+       int err = 0;
+
+       // PTB go through and copy and protect the written buffers
+       for (bh = req->bh; bh; bh = bh->b_reqnext) {
+               struct buffer_head *rbh;
+               rbh =
+                getblk (bh->b_rdev, bh->b_rsector / (bh->b_size >> 9),
+                        bh->b_size);
+               if (bh != rbh) {
+                       char *bdata = bh_kmap (bh);
+                       memcpy (rbh->b_data, bdata, rbh->b_size);
+                       NBD_ALERT ("got new bh sector %lu on write\n",
+                                  bh->b_rsector);
+               }
+               bh_kunmap (bh);
+               mark_buffer_protected (rbh);    // PTB equals dirty, uptodate
+               err = buffered_write_pagecache_IO (bh, nbd);
+               if (err < 0) {
+                       break;
+               }
+               brelse (rbh);
+       }
+       return err;
+}
+
+#endif         /* NO_BUFFERED_WRITES */
+
+/* 
+ * PTB check if the device is read only according to int flags
+ *
+ *   @lo the nbd device to be checked
+ */
+static int
+nbd_read_only(struct nbd_device *lo) {
+        return (atomic_read(&lo->flags) & NBD_READ_ONLY) != 0;
+}
+/*
+ * PTB set the device readonly (or not)
+ *
+ *   @lo the nbd device to be set up
+ *   @ro 1 for read only, 0 for read write.
+ */
+static void
+nbd_set_read_only(struct nbd_device * lo, int ro) {
+
+        if (ro != 0) {
+                atomic_set_mask (NBD_READ_ONLY, &lo->flags);
+        } else {
+               atomic_clear_mask (NBD_READ_ONLY, &lo->flags);
+       }
+
+        // PTB which device really does not matter. We do the checking.
+        set_disk_ro (lo->disk, ro != 0);
+}
+
+/*
+ * PTB - kernel function to take reqs off the kernel queue. Runs with
+ * io lock held. This is the "request function".
+ */
+static void
+do_nbd_request (request_queue_t * q)
+{
+       struct request *req;
+       unsigned long flags;
+
+       while (! blk_queue_empty(q)) {
+
+               struct nbd_device *lo;
+
+                req = elv_next_request(q);
+
+               lo = req->rq_disk->private_data;
+
+                /* PTB - one kernel thread enters */
+               atomic_inc (&lo->kthreads);
+
+               if (atomic_read (&lo->kthreads) > atomic_read (&lo->kmax))
+                       atomic_set (&lo->kmax, atomic_read (&lo->kthreads));
+
+               if (!lo->inode || !lo->file) {
+                       NBD_FAIL ("Request when device not ready.");
+               }
+
+               if (rq_data_dir (req) == WRITE && nbd_read_only(lo)) {
+                       NBD_FAIL ("write on read-only device");
+               }
+               flags = atomic_read (&lo->flags);
+               if (!(flags & NBD_INITIALISED)) {
+                       NBD_FAIL ("device not initialised.");
+               }
+               if (!(flags & NBD_ENABLED)) {
+                       NBD_FAIL ("device not enabled.");
+               }
+               if (flags & NBD_REMOTE_INVALID) {
+                       NBD_FAIL ("remote device invalidated.");
+               }
+               if (req->sector + req->nr_sectors > lo->sectors) {
+                       NBD_FAIL ("overrange request");
+               }
+               if (req->sector < 0) {
+                       NBD_FAIL ("underrange request");
+               }
+               if (req->rq_disk->major != major) {
+                       NBD_FAIL ("request for wrong major");
+               }
+               req->errors = 0;
+               blkdev_dequeue_request (req);
+
+                // PTB in 2.5 we can release the iolock briefly here
+                spin_unlock_irq(q->queue_lock);
+
+                if (req->flags & REQ_SPECIAL) {
+                        // PTB temporary successful end here for SPECIALS
+
+                        // PTB we want to attach it to the device and ack later
+                       nbd_enqueue (lo, req);
+                        // PTB block further reqs until these have drained
+                        write_lock(&lo->altqueue_lock);
+                        // PTB do not touch this flag without this lock
+                        if (atomic_read(&lo->countq[READ])
+                          + atomic_read(&lo->countq[WRITE]) > 0) {
+                            atomic_set_mask(NBD_QBLOCKED, &lo->flags);
+                        }
+                        write_unlock(&lo->altqueue_lock);
+                       goto accounting;
+                }
+
+               // PTB we are the only reader and writer of lo->seqno
+               if (rq_data_dir (req) == WRITE && rq_seqno (req) == 0) {
+                       // PTB it is a new request never seen before
+                        struct nbd_seqno * seqno_out = &lo->seqno_out;
+                        seqno_out->inc(seqno_out);
+                       /*
+                         * PTB we have to be careful to change this back before
+                        * giving it back to the kernel, as the kernel uses it.
+                        * We patch it back again in nbd_end_request.
+                         */
+                       rq_set_seqno (req, seqno_out->get(seqno_out));
+               }
+
+                // if BLOCK is set divert requests to alt queue
+                write_lock(&lo->altqueue_lock);
+                if (atomic_read(&lo->flags) & NBD_QBLOCKED) {
+                        list_add (&req->queuelist, &lo->altqueue);
+                        write_unlock(&lo->altqueue_lock);
+                       goto accounting;
+                }
+                write_unlock(&lo->altqueue_lock);
+
+               // PTB normal sequence is to queue request locally
+               nbd_enqueue (lo, req);
+               goto accounting;
+
+             accounting:
+               atomic_dec (&lo->kthreads);
+                // PTB regain the iolock for another turn
+                spin_lock_irq(q->queue_lock);
+               continue;       // PTB next request
+
+             error_out:
+               // PTB can rely on req being nonnull here
+               NBD_ALERT ("ending req %p with prejudice\n", req);
+               req->errors++;
+               blkdev_dequeue_request (req);
+                spin_unlock_irq(q->queue_lock);
+
+               nbd_end_request_lock (req);
+                blk_put_request (req);
+
+                // PTB more accounting
+               if (lo) {
+                       int req_blks = nr_blks (req);
+                       atomic_add (req_blks, &lo->requests_err);
+                       atomic_dec (&lo->kthreads);
+               } else {
+                        NBD_ALERT("failed to account one orphan errored req\n");
+                }
+                // PTB regain the queue lock for another turn
+                spin_lock_irq(q->queue_lock);
+                continue;
+       }
+        return;
+}
+
+/*
+ * PTB pair of helpful additional functions, only good for 1 bit in the
+ * mask, however. Modify if you want more.
+ *
+ *   @a the atomic element's address
+ *   @mask the integer with one bit set in the position that we want to test
+ *         and set, or clear
+ */
+static int
+atomic_test_and_set_mask (atomic_t * a, unsigned mask)
+{
+       int i = ffs (mask);
+       if (!i)
+               return -EINVAL;
+                // PTB gahhhh ...
+        #ifdef __LITTLE_ENDIAN
+               return test_and_set_bit (i - 1, (unsigned long *)&a->counter);
+        #else
+                #ifndef __BIGENDIAN
+                #error help, I only know about bigendian or littlendian machines
+                #endif
+               return test_and_set_bit
+                    (i - 1 + (sizeof(long)-sizeof(a->counter))*8,
+                        (unsigned long *)&a->counter);
+        #endif
+}
+static int
+atomic_test_and_clear_mask (atomic_t * a, unsigned mask)
+{
+       int i = ffs (mask);
+       if (!i)
+               return 0;
+                // PTB gahhhh ...
+        #ifdef __LITTLE_ENDIAN
+               return test_and_clear_bit (i - 1, (unsigned long *)&a->counter);
+        #else
+                #ifndef __BIGENDIAN
+                #error help, I only know about bigendian or littlendian machines
+                #endif
+               return test_and_clear_bit
+                    (i - 1 + (sizeof(long)-sizeof(a->counter))*8,
+                        (unsigned long *)&a->counter);
+        #endif
+}
+
+
+/*
+ * PTB - set the enabled flag on a device (call without the spinlock held) 
+ *
+ *   @lo the nbd device being treated
+ */
+static void
+nbd_enable (struct nbd_device *lo) {
+       unsigned long flags;
+        int did_enabled = 0;
+        struct nbd_md *md = &nbd_md;
+
+       // PTB reenable part
+       write_lock_irqsave (&lo->meta_lock, flags);
+       if (!atomic_test_and_set_mask (&lo->flags, NBD_ENABLED)) {
+                // PTB was not enabled before
+               atomic_clear_mask (NBD_VALIDATED, &lo->flags);
+               lo->lives++;
+                did_enabled = 1;
+       } 
+       write_unlock_irqrestore (&lo->meta_lock, flags);
+
+        if (did_enabled)
+                md->notify(&nbd_md, mk_kdev (major, lo->nbd << NBD_SHIFT));
+}
+
+
+/*
+ * PTB rollback all requests on a given slot and then invalidate it
+ * (so the requests can't go back until somebody reactivates the slot)
+ * At least rollback (which we call takes both the io spinlock and our
+ * spinlock, so we can hold neither when we are called. Soft_reset
+ * (which we call) also calls rollback, so has the same problem.
+ *
+ *   @slot the nbd slot being treated
+ */
+static int
+nbd_clr_sock (struct nbd_slot *slot)
+{
+       int i = 0;
+       struct nbd_device *lo = slot->lo;
+       int islot = slot->i;
+       unsigned long flags;
+        int do_reset = 0;
+        int do_enable = 0;
+       static int nbd_soft_reset (struct nbd_device*);
+
+       nbd_rollback_all (slot);
+
+       slot->file = NULL;
+       slot->bufsiz = 0;
+       slot->flags = 0;
+       slot->buffer = NULL;
+
+       write_lock_irqsave (&lo->meta_lock, flags);
+
+       /* PTB reset lo->aslot */
+
+       if (lo->aslot > 0) {
+
+               /* PTB grr .. do this the hard way */
+               int aslot = 0;
+               for (i = 0; i < lo->nslot; i++) {
+                       struct nbd_slot *sloti = &lo->slots[i];
+                       if (sloti->file)
+                               aslot++;
+               }
+                lo->aslot = aslot;
+
+               if (lo->aslot <= 0) {
+                       // PTB we were the last client alive, diasable device
+                       if (atomic_read (&lo->flags) & NBD_SHOW_ERRS) {
+                               // PTB soft_reset will invalidate_buffers
+                               atomic_clear_mask (NBD_ENABLED, &lo->flags);
+                                do_reset = 1;
+                       }
+               } else if (!(atomic_read (&lo->flags) & NBD_ENABLED)) {
+                       // PTB must not call reenable as that clears the queue
+                        do_enable = 1;
+               }
+
+       }
+
+        // PTB lift the lock temporarily
+       write_unlock_irqrestore(&lo->meta_lock, flags);
+        if (do_reset) {
+               nbd_soft_reset (lo);
+        }
+        if (do_enable) {
+                nbd_enable (lo);
+               NBD_ALERT ("enabled device nd%s\n", lo->devnam);
+        }
+       write_lock_irqsave(&lo->meta_lock, flags);
+
+       /* PTB reset lo->islot, for no good reason */
+
+       if (atomic_read (&lo->islot) == islot) {
+               for (i = 0; i++ < lo->nslot;) {
+                       atomic_inc (&lo->islot);
+                       if (atomic_read (&lo->islot) >= lo->nslot)
+                               atomic_set (&lo->islot, 0);
+                       if (lo->slots[atomic_read (&lo->islot)].file)
+                               break;
+               }
+       }
+       lo->harderror = 0;
+       write_unlock_irqrestore (&lo->meta_lock, flags);
+
+       /* PTB don't clear whole device queue as we might still be open */
+
+       return 0;
+}
+
+/*
+ * PTB - check all slots for old requests and roll them back. 
+ * At least rollback (which we call takes both the io spinlock and our
+ * spinlock, so we can hold neither when we are called.
+ *
+ *   @lo the nbd device to scan
+ */
+static void
+nbd_rollback_old (struct nbd_device *lo)
+{
+
+       int islot;
+
+       for (islot = 0; islot < lo->nslot; islot++) {
+               struct nbd_slot *slot = &lo->slots[islot];
+               if (slot->req_age > 0
+                   && slot->req_age < jiffies - lo->req_timeo * HZ) {
+                       nbd_rollback_all (slot);
+               }
+       }
+
+}
+
+/*
+ * PTB - register a socket to a slot.
+ *     - Return 0 for success and -ve for failure.
+ *       Nowadays this doesn't do very much! Just finalizes things.
+ *
+ *       @slot  the nbd slot being registered
+ */
+static int
+nbd_set_sock (struct nbd_slot *slot, int arg)
+{
+
+       struct nbd_device *lo = slot->lo;
+       int islot = slot->i;
+       unsigned long flags;
+        int do_enable = 0;
+
+       if (!(atomic_read (&lo->flags) & NBD_INITIALISED)) {
+               NBD_ALERT ("(%d) device nd%s not initialised yet!\n",
+                          islot, lo->devnam);
+               return -ENODEV;
+       }
+       if (!(atomic_read (&lo->flags) & NBD_SIZED)) {
+               NBD_ALERT ("(%d) device nd%s not sized yet!\n", islot,
+                        lo->devnam);
+               return -EINVAL;
+       }
+       if (!(atomic_read (&lo->flags) & NBD_BLKSIZED)) {
+               NBD_ALERT ("(%d) device nd%s not blksized yet!\n", islot,
+                        lo->devnam);
+               return -EINVAL;
+       }
+       if (!(atomic_read (&lo->flags) & NBD_SIGNED)) {
+               NBD_ALERT ("(%d) setting unsigned device nd%s! But harmless.\n",
+                          islot, lo->devnam);
+               return -EINVAL;
+       }
+
+       down (&lo->pid_sem);
+
+       if (slot->pid != current->pid) {
+                if (jiffies > slot->cli_age + 2 * HZ * lo->req_timeo) {
+                       NBD_ALERT
+                       ("(%d) dead client process %d has nd%s%d, erasing pid!\n",
+                         islot, slot->pid, lo->devnam, islot + 1);
+                        slot->pid = 0;
+                } else {
+                       NBD_ALERT
+                       ("(%d) other live client process %d has nd%s%d!\n",
+                         islot, slot->pid, lo->devnam, islot + 1);
+                }
+               up (&lo->pid_sem);
+               return -EINVAL;
+       }
+       up (&lo->pid_sem);
+
+       slot = &lo->slots[islot];
+
+       // PTB this is a queue critical code region for the flags business
+       write_lock_irqsave (&lo->meta_lock, flags);
+
+       // PTB file has to be nonzero to indicate we are all set up. 
+        slot->file = (void *) (unsigned long) (arg+1 > 0 ? arg+1 : 1);
+
+       if (islot >= lo->nslot) {
+               lo->nslot = islot + 1;
+               NBD_INFO ("increased socket count to %d\n", lo->nslot);
+       }
+
+       lo->harderror = 0;
+
+        if (lo->disk && !get_capacity(lo->disk)) {
+                set_capacity(lo->disk, lo->sectors);
+        }
+       if (++lo->aslot > 0) {
+                do_enable = 1;
+        }
+       // PTB end of queue critical region
+       write_unlock_irqrestore (&lo->meta_lock, flags);
+
+        /*
+        * PTB if this is the first slot, we might call reenable and
+        * thus clr queue too, but reenable takes the spinlock
+         */
+        if (do_enable)
+                nbd_enable(lo);
+        
+       return 0;
+}
+
+/*
+ * PTB - return the index i of 2^i + j, 0 <= j < 2^i
+ */
+static inline unsigned
+log2 (unsigned arg)
+{
+       unsigned log = 0;
+       while ((arg >>= 1) > 0)
+               log++;
+       return log;
+}
+
+/*
+ * PTB - set the blksize in bytes of the block device. Return 0 for
+ *     - success and -ve for failure.
+ */
+static int
+nbd_set_blksize (struct nbd_device *lo, unsigned int arg)
+{
+       int nbd = lo->nbd;
+       if (arg > PAGE_SIZE || arg < 512 || (arg & (arg - 1))) {
+               NBD_ERROR ("blksize too big (%u)\n", arg);
+               return -EINVAL;
+       }
+       lo->blksize = nbd_blksizes[nbd << NBD_SHIFT] = arg;
+       lo->logblksize = log2 (lo->blksize);
+        set_blocksize(lo->inode->i_bdev, lo->blksize);
+       atomic_set_mask (NBD_BLKSIZED, &lo->flags);
+       return 0;
+}
+
+/*
+ * PTB - set the size in bytes of the block device. Return 0 for
+ *     - success and -ve for failure.
+ */
+static int
+nbd_set_size (struct nbd_device *lo, __u64 arg)
+{
+       int nbd = lo->nbd;
+       lo->bytesize = nbd_bytesizes[nbd << NBD_SHIFT] = arg;
+       lo->size     = nbd_sizes[nbd << NBD_SHIFT] = arg >> 10;
+       lo->sectors  = lo->size << 1;
+        if (lo->inode && lo->inode->i_bdev && lo->inode->i_bdev->bd_inode)
+                lo->inode->i_bdev->bd_inode->i_size = arg;
+        if (lo->disk)
+                set_capacity (lo->disk, arg >> 9);
+       atomic_set_mask (NBD_SIZED, &lo->flags);
+       return 0;
+}
+
+/* WG */
+static int
+nbd_set_intvl (struct nbd_device *lo, int arg)
+{
+       if (arg <= 0) {
+               NBD_ERROR ("bad pulse interval/req timeout value (%d)\n", arg);
+               return -EINVAL;
+       }
+       lo->req_timeo = arg;
+       return 0;
+}
+
+static int
+nbd_set_spid (struct nbd_slot *slot, int arg)
+{
+       short spid = arg;
+       if (arg < 0 || arg >= (1 << (sizeof (short) * 8))) {
+               NBD_ERROR ("bad spid value (%d)\n", arg);
+               return -EINVAL;
+       }
+       slot->spid = spid;
+       return 0;
+}
+
+static int
+nbd_set_bufferwr (struct nbd_device *lo, int arg)
+{
+       if (arg) {
+               atomic_set_mask (NBD_BUFFERWR, &lo->flags);
+       } else {
+               atomic_clear_mask (NBD_BUFFERWR, &lo->flags);
+       }
+       return 0;
+}
+
+static int
+nbd_set_remote_invalid (struct nbd_device *lo, int arg)
+{
+       /*
+         * PTB we handle the event ourself exactly when it happens
+        * instead of letting the kernel have check_media defined
+        * and doing it there (and reporting 0 to the kernel)
+         */
+       unsigned long flags;
+        int do_invalidate = 0;
+       kdev_t dev = mk_kdev (major, lo->nbd << NBD_SHIFT);
+
+       if (arg == 0) {
+               atomic_clear_mask (NBD_REMOTE_INVALID, &lo->flags);
+               return 0;
+       }
+
+       write_lock_irqsave (&lo->meta_lock, flags);
+       if (!(atomic_test_and_set_mask (&lo->flags, NBD_REMOTE_INVALID))) {
+               /*
+                 * PTB this tells the kernel that next open
+                * should cause recheck .. we'll agree not to
+                * say we're happy until VALID is set again
+                 */
+               atomic_clear_mask (NBD_VALIDATED, &lo->flags);
+               // PTB test removing partitions
+                do_invalidate = 1;
+        }
+       write_unlock_irqrestore (&lo->meta_lock, flags);
+
+        if (do_invalidate) {
+               // PTB destroy buffers
+               __invalidate_buffers (dev, 1);
+               NBD_ALERT ("invalidating remote on nd%s\n", lo->devnam);
+               // PTB - clear buffers now instead of waiting for kernel
+               // PTB that will cause requests to start being errored
+               invalidate_device (dev, 0);
+       } 
+
+       return 0;
+}
+/*
+ * Return the first slot index free when asking for n new ones.
+ * If there s no such gap, then NBD_MAXCONN will be returned.
+ * The return is always in the same argument address.
+ */
+static int
+nbd_get_nport (struct nbd_device *lo, int *arg)
+{
+       int err, nslot, i;
+
+       if (arg == NULL) {
+               return -EINVAL;
+       }
+
+       nslot = *arg;
+       err = copy_from_user ((char *) &nslot, arg, sizeof (int));
+       if (err < 0) {
+               return err;
+       }
+
+       for (i = 0; i < NBD_MAXCONN; i++) {
+               struct nbd_slot *sloti = &lo->slots[i];
+               int j;
+               if (sloti->file) {
+                       continue;
+               }
+
+               for (j = i; j < NBD_MAXCONN && j < i + nslot; j++) {
+                       if (sloti->file)
+                               break;
+               }
+               if (j == i + nslot) {
+
+                       break;
+               }
+       }
+
+       err = copy_to_user (arg, (char *) &i, sizeof (int));
+       return err;
+}
+
+
+/*
+ * PTB - if we're not signed, accept new sig and return success.
+ *     - if we are signed, compare the offer and return success if equal,
+ *     - and -ve for failure.
+ *
+ *       @slot the slot we're working on
+ *       @sig  the string of signature chars (accessed as int *)
+ */
+static int
+nbd_set_sig (struct nbd_slot *slot, int *sig)
+{
+       int err = 0;
+       int buf[NBD_SIGLEN / sizeof (int)];
+       int islot = slot->i;
+       struct nbd_device *lo = slot->lo;
+
+       if (!access_ok (VERIFY_READ, (char *) sig, NBD_SIGLEN)) {
+               NBD_ALERT ("(%d): failed sigcheck with bad user address %p\n",
+                          islot, sig);
+               err = -EINVAL;
+               return err;
+       }
+       down (&lo->pid_sem);
+
+       if (slot->pid == 0) {
+               slot->pid = current->pid;
+               slot->cli_age = jiffies;
+       }
+       if (slot->pid != current->pid) {
+                if (jiffies > slot->cli_age + 2 * HZ * lo->req_timeo) {
+                       NBD_ALERT
+                       ("(%d): dead process %d was setting sig, erasing pid\n",
+                       islot, slot->pid);
+                        slot->pid = 0;
+                } else {
+                       NBD_ALERT
+                       ("(%d): live process %d is trying to set sig\n",
+                       islot, slot->pid);
+                }
+               up (&lo->pid_sem);
+               return -EINVAL;
+       }
+
+       if (!(atomic_read (&lo->flags) & NBD_SIGNED)) {
+               /* PTB first time grab sig */
+               copy_from_user ((char *) lo->signature, (char *) &sig[0],
+                               NBD_SIGLEN);
+               atomic_set_mask (NBD_SIGNED, &lo->flags);
+               up (&lo->pid_sem);
+               return 0;
+       }
+       copy_from_user ((char *) buf, (char *) &sig[0], NBD_SIGLEN);
+
+       /* PTB test for equality */
+
+       if (memcmp (&buf[0], &lo->signature[0], NBD_SIGLEN / sizeof (int))
+           != 0) {
+               err = -EINVAL;
+               up (&lo->pid_sem);
+               NBD_ALERT ("(%d): failed sigcheck wth %d\n", islot, err);
+               return err;
+       }
+       up (&lo->pid_sem);
+       err = 0;
+       return err;
+}
+
+/*
+ * PTB - register a userspace buffer to a slot. Return 0 for success
+ *     - and -ve for failure. Null arg acts as erase.
+ */
+static int
+nbd_reg_buf (struct nbd_slot *slot, char *buffer)
+{
+
+       int err = 0, siz;
+       struct nbd_device *lo = slot->lo;
+
+       if (!buffer) {
+               slot->flags &= ~NBD_SLOT_BUFFERED;
+               slot->buffer = NULL;
+               slot->bufsiz = 0;
+               return 0;
+       }
+
+       siz = lo->max_sectors << 9;
+
+       /* verify the buffer is in the process space */
+       if (!access_ok (VERIFY_WRITE, buffer, siz)) {
+               err = -EINVAL;
+               return err;
+       }
+       /* PTB hope the buffer is as big as it should be - FIXME */
+       slot->buffer = buffer;
+       slot->bufsiz = siz;
+
+       /* PTB let the device bufsiz be min of registered nonzero bufsizes */
+       if (!lo->bufsiz) {
+               // PTB first time
+               lo->bufsiz = siz;
+       } else {
+               if (lo->bufsiz > siz)
+                       lo->bufsiz = siz;
+       }
+
+       // PTB just in case the buffer really is small, we reset all the
+       //     kernels request maxima if we have to adjust the device max
+       if (lo->max_sectors < (lo->bufsiz >> 9)) {
+               int j;
+               lo->max_sectors = lo->bufsiz >> 9;
+               for (j = 0; j < NBD_MAXCONN; j++) {
+                       nbd_max_sectors[(lo->nbd << NBD_SHIFT) + j] =
+                        lo->max_sectors;
+               }
+       }
+
+       slot->flags |= NBD_SLOT_BUFFERED;
+       return 0;
+}
+
+/*
+ * PTB - this unsets the enabled flag on the device and then clears the
+ *     - queue for the device.. Call without spinlock.
+ *
+ *       @lo the nbd device to scan
+ */
+static int
+nbd_disable (struct nbd_device *lo)
+{
+        struct nbd_md * md = &nbd_md;
+
+       if (!lo || !(atomic_read (&lo->flags) & NBD_INITIALISED)) {
+               NBD_ALERT("nbd_disable called on bad device\n");
+               return 0;
+       }
+
+        if (atomic_test_and_clear_mask (&lo->flags, NBD_ENABLED)) {
+                NBD_ALERT ("disabled device nd%s\n", lo->devnam);
+        }
+
+        md->unnotify(md, mk_kdev (major, lo->nbd << NBD_SHIFT));
+
+        // PTB have to recheck partitions on next open
+        if (atomic_test_and_clear_mask (&lo->flags, NBD_VALIDATED)) {
+               NBD_ALERT ("invalidated device nd%s\n", lo->devnam);
+        }
+        return 0;
+}
+
+
+/*
+ * PTB - reset the enabled flag on a device and then clear all queues
+ * ( call without the spinlock held )  and then enable again.
+ */
+static void
+nbd_reenable (struct nbd_device *lo)
+{
+
+       int m, n;
+
+       if (!(atomic_read (&lo->flags) & NBD_INITIALISED))
+               return;
+       if (lo->aslot <= 0)
+               return;
+        if ((atomic_read (&lo->flags) & NBD_ENABLED))
+                return;
+
+       m = nbd_clr_queue (lo);
+       // PTB - have to call clr_kernel_queue without the io_spinlock held
+       n = nbd_clr_kernel_queue (lo);
+
+        nbd_enable(lo);
+}
+
+/*
+ *  This function launches a thread which wakes for a signal to reenable
+ *  the device, and then sets the timer to deleiver the signal.
+ */
+static int
+nbd_reenable_delay (struct nbd_device *lo, int delay)
+{
+       write_lock (&lo->meta_lock);
+       if (lo->reenable_time == 0)
+               lo->reenable_time = jiffies + delay * HZ;
+       write_unlock (&lo->meta_lock);
+       return 0;
+}
+
+
+
+/*
+ * PTB - drains device queue. Disables device.
+ * At least rollback (which we call takes both the io spinlock and our
+ * spinlock, so we can hold neither when we are called. Also
+ * invalidate buffers, on request of Rogier Wolff.
+ */
+static int
+nbd_soft_reset (struct nbd_device *lo)
+{
+       int j;
+        const int max_clrq_retries = 100;
+       if (!(atomic_read (&lo->flags) & NBD_INITIALISED) || lo->nslot <= 0) {
+               return -EINVAL;
+       }
+       /*
+         * PTB We push back the requests in the slot, in order to be able to
+        * vamoosh them in a moment. This is a race, surely? We ought to
+        * do this atomically or dsiable the slots first.
+         */
+       for (j = 0; j < lo->nslot; j++) {
+               struct nbd_slot *slot = &lo->slots[j];
+               nbd_rollback_all (slot);
+       }
+       // PTB disable unsets the nabled flag and clears the queue
+       nbd_disable (lo);
+        for (j = 0; j < max_clrq_retries; j++) {
+               int m = nbd_clr_queue (lo);
+                if (m <= 0)
+                        break;
+        }
+       // PTB this would unsign the device: lo->flags &= ~NBD_SIGNED;
+
+       /*
+         * PTB put back invalidate buffers for use when called from
+        * clr_sock from nbd_release on request of Rogier Wolff.
+         */
+       for (j = 0; j < lo->nslot; j++) {
+               invalidate_buffers (mk_kdev(major, (lo->nbd << NBD_SHIFT) + j));
+       }
+       return 0;
+}
+
+/*
+ * PTB - added a device/module reset for tidyness in face of rampant hacking
+ *     - this does a soft_reset of all devices, followed bu a clr sock
+ *     - on each, and then clears the kernel queue. It unsets the
+ *     - enabled flag on each device.
+ *       We have to be called without either the spinlock or the
+ *       spinlock held, as we call soft_reset which takes both, as
+ *       does clr_sock
+ */
+int
+nbd_hard_reset (struct nbd_device *lo)
+{
+       int i;
+       int err = 0;
+
+       for (i = 0; i < MAX_NBD; i++) {
+               struct nbd_device *lo = &nbd_dev[i];
+               int j;
+                if (!lo->file || !lo->inode)
+                      continue;
+                if (!(atomic_read(&lo->flags)&NBD_INITIALISED))
+                      continue;
+               nbd_soft_reset (lo);
+               for (j = 0; j < lo->nslot; j++) {
+                       struct nbd_slot *slot = &lo->slots[j];
+                       //  PTB this takes the io spinlock and our spinlock.
+                       nbd_clr_sock (slot);
+               }
+               // PTB - call clr_kernel_queue without the io_spinlock held
+               nbd_clr_kernel_queue (lo);
+       }
+
+       return err;
+}
+
+static int
+indirect_ioctl_load (struct request *req, int cmd, char * buf)
+{
+
+        int size;
+        int err;
+        struct nbd_ioctl *remote_ioctl = nbd_remote_ioctl.remote;
+
+        if (!remote_ioctl)
+                return -EINVAL;
+
+       size = remote_ioctl->size_user (cmd, buf);
+
+       if (size < 0) {
+                // PTB unauthorized ioctl
+                err = -EINVAL;
+                goto error_out;
+       }
+
+        if (size == 0) {
+                 // PTB we never use the nbd devices small buffer now
+                 req->nr_sectors = 0;
+                 req->buffer = NULL;
+                 return size;
+        }
+
+        // PTB we have to use an extra buffer or else block
+       // here and rendezvous directly with the get_req call
+        req->nr_sectors = (size + 511) >> 9;
+        req->buffer = kmalloc(req->nr_sectors << 9, GFP_KERNEL);
+
+       if (!req->buffer) {
+                 err = -ENOMEM;
+                 goto error_out;
+       }
+
+       if (_IOC_DIR (cmd) & _IOC_WRITE) {
+               err =
+                remote_ioctl->cp_from_user (cmd, req->buffer, buf, size);
+               if (err < 0) {
+                       kfree (req->buffer);
+                        goto error_out;
+               }
+       }
+        return size;
+
+error_out:
+        req->buffer = NULL;
+        req->nr_sectors =0;
+        return err;
+}
+
+static int
+indirect_ioctl_store (struct request *req, int cmd, char * buf,
+                     int size)
+{
+        int err;
+        struct nbd_ioctl * remote_ioctl = nbd_remote_ioctl.remote;
+
+        if (!remote_ioctl)
+                return -EINVAL;
+
+        if (size <= 0)
+                return size;
+
+       // PTB if we are reading, it should be to the local buffer
+       // PTB the buffer points at a kmalloced area
+        
+        if (!req->buffer)
+                return -ENOMEM;
+       err = remote_ioctl->cp_to_user (cmd, buf, req->buffer, size);
+       kfree (req->buffer);
+       if (err < size)
+               return -ENOMEM;
+       return size;
+}
+
+static int
+do_nbd_remote_ioctl(struct nbd_device *lo, int minor, int cmd, unsigned long arg) {
+
+       unsigned start_time, timeout;
+       size_t size;
+        int err;
+        struct request * req;
+        struct completion x;
+
+       /*
+         * PTB here we have to treat remote ioctls. We should probably make
+        * a request and put it on the local queue, but where can we get
+        * the request from? We might have to keep one in reserve.
+        * That's not a bad idea, because
+        * we generate it here and we delete it here, and the daemon code
+        * is all set up to read that sort of thing. So that's what we do ...
+         */
+
+       timeout = lo->req_timeo * HZ;
+       start_time = jiffies;
+
+        while (!(req = blk_get_request(lo->q,WRITE,0))) {
+               if (jiffies >= start_time + timeout) {
+                       // PTB it takes too long
+                       NBD_ALERT
+                        ("took too long to get a spare ioctl req: TIMEOUT\n");
+                       return -ETIME;
+               }
+               err = interruptible_sleep_on_timeout (&lo->req_wq,
+                                                     start_time +
+                                                     timeout - jiffies);
+       }
+
+       set_rq_type(req, IOCTL);
+
+       req->errors = 0;
+
+       // PTB this is the fixed-up command
+       req->special = (void *) cmd;
+
+       /*
+         * PTB this is (arg if it is direct, else) the address of a local buffer
+        * PTB we need to store the arg or its dereference somewhere local
+        * for a while until the cnb-client thread can enter and pick it
+        * up. The alternative is to block the ioctl here until it is
+        * picked up, which IS possible.
+         */
+        
+       if (_IOC_DIR (cmd) & _IOC_READ) {
+               // PTB indirect
+                size = indirect_ioctl_load (req, cmd, (char *)arg);
+                if (size < 0) {
+                    goto end;
+                }
+       } else {
+               // PTB direct - we just need to remember the value
+               size = 0;
+               req->buffer = (char *) arg;
+       }
+
+       // PTB point the request buffer vaguely in the direction of where
+       // the data is, but it does not matter.
+       req->rq_disk = lo->disk;
+
+       // PTB we queue the request for treatment and wait till treated
+        init_completion(&x);
+        req->waiting = &x;
+       nbd_enqueue (lo, req);
+
+        for (err = 0; err <= 0; err = wait_for_completion_timeout(&x, 1)) {
+
+                /*
+                 * PTB on slot or queue? Don't know.  Only want
+                 * to vamoosh it if its on queue, not slot
+                 */
+               struct list_head *pos;
+                int time_left = start_time + timeout - jiffies;
+                // PTB del_req will be run with queue_lock held
+                static void delete_req(void) {
+
+                        // PTB change countq only under this lock
+                        if (! (req->flags & REQ_SPECIAL)) {
+                                write_lock(&lo->altqueue_lock);
+                                // PTB reverse inadvertent accounting in enqueue
+                                atomic_dec (&lo->countq[rq_data_dir(req)]);
+                                write_unlock(&lo->altqueue_lock);
+                        }
+
+                       list_del_init (&req->queuelist);
+
+                       req->errors = -ETIME;
+                       if (req->nr_sectors > 0 && req->buffer) {
+                               kfree (req->buffer);
+                                req->buffer = NULL;
+                       }
+                };
+
+               if (time_left > 0)
+                        continue;
+
+                // PTB find req on list and delete it
+                write_lock (&lo->queue_lock);
+               list_for_each (pos, &lo->queue) {
+
+                       if (req != list_entry (pos, struct request, queuelist)) 
+                                continue;
+
+                        delete_req ();
+                       write_unlock (&lo->queue_lock);
+                       NBD_ALERT
+                         ("took too long to treat queued ioctl: TIMEOUT\n");
+                       err = -ETIME;
+                        goto end;
+                }
+               write_unlock (&lo->queue_lock);
+
+       } // end while loop
+
+
+       if (_IOC_DIR (cmd) & _IOC_READ) {
+                err = indirect_ioctl_store(req, cmd, (char *)arg, size);
+                if (err < 0) {
+                    goto end;
+                }
+       }
+
+       if (req->errors != 0) {
+                err = req->errors;
+               err = err < 0 ? err : -EINVAL;
+       } else {
+                err = 0;
+        }
+end:
+        blk_put_request(req);
+       return err;
+
+}
+
+static int
+find_slot (struct nbd_device *lo, int pid)
+{
+        int i;
+       // go search
+       for (i = 0; i < NBD_MAXCONN; i++) {
+                struct nbd_slot * slot =  &lo->slots[i];
+               if (slot->pid == pid)
+                       break;
+       }
+       if (i < NBD_MAXCONN)
+               return i;               // found it
+       // not found
+       return -1;
+}
+
+static int
+fixup_slot (struct nbd_device *lo, int islot, unsigned int cmd, unsigned long *arg)
+{
+       int intval;
+
+       switch (cmd) {
+
+               // PTB get slot info from parameter if not given
+         case NBD_CLEAR_SOCK:
+         case MY_NBD_CLR_REQ:
+         case MY_NBD_ERR_REQ:
+               // see if we match a known slot pid
+               if (arg && *arg == 0) {
+                       islot = find_slot (lo, current->pid);
+                       if (islot >= 0)
+                               return islot;
+               }
+               NBD_ALERT
+                ("failed to find slot for pid %d for ioctl %x arg %lx\n",
+                 current->pid, cmd, *arg);
+               return islot = -1;
+               break;
+
+               // PTB get the slot from the 16 high bits
+         case NBD_SET_SOCK:
+         case MY_NBD_SET_SPID:
+               intval = *arg >> ((sizeof (int) - sizeof (short)) * 8);
+               intval &= (1 << (sizeof (short) * 8)) - 1;
+               if (intval == 0) {
+                       // no clue in the pid high bits. Search
+                       islot = find_slot (lo, current->pid);
+                       if (islot >= 0) {
+                               // PTB change arg !!
+                               *arg &= (1 << (sizeof (short) * 8)) - 1;
+                               return islot; // found it
+                       }
+                       // not found
+               }
+               NBD_ALERT
+                    ("failed to find slot for pid %d for ioctl %x arg %lx\n",
+                   current->pid, cmd, *arg);
+               return islot = -1;
+               break;
+
+         case MY_NBD_GET_REQ:
+         case MY_NBD_ACK:
+               islot = find_slot (lo, current->pid);
+               if (islot >= 0)
+                       return islot;
+               NBD_ALERT
+                ("failed to find slot for pid %d for ioctl %x arg %lx\n",
+                 current->pid, cmd, *arg);
+               return islot;
+               break;
+
+         case MY_NBD_REG_BUF:
+         case MY_NBD_SET_SIG:
+               islot = find_slot (lo, current->pid);
+               if (islot >= 0)
+                       return islot;
+               /*
+                 * PTB Otherwise they passed a buffer
+                * and the slot number is in the first 4B
+                * We need some magic here for safety!
+                * set sig is the only call that really needs
+                * to send its pid!
+                 */
+
+                intval = -1;
+               if (!arg || !*arg || get_user (intval, (int *) *arg)
+               || intval <= 0
+                || intval > NBD_MAXCONN) {
+                       NBD_ALERT
+                        ("failed to find slot for pid %d ioctl %x arg %lx\n",
+                               current->pid, cmd, *arg);
+                       return islot = -1;
+               }
+               islot = intval - 1;
+
+               // PTB CHANGE ARG !!!!
+               *arg += sizeof (int);
+               return islot;
+               break;
+       }
+
+       return islot = -1;
+}
+
+/*
+ * PTB - generic ioctl handling
+ */
+static int
+nbd_ioctl (struct inode *inode, struct file *file,
+          unsigned int cmd, unsigned long arg)
+{
+       struct nbd_device *lo
+                  = NULL;      // PTB device pointer
+       int minor = -1;         // PTB minor on which we got the ioctl
+       int islot = -1;         // PTB slot number 0, 1, ...
+       int nbd   = -1;         // PTB the count for the device group
+       struct nbd_slot *slot
+                  = NULL;      // PTB slot pointer
+        int err;
+
+       if (!capable(CAP_SYS_ADMIN)) {
+               NBD_ERROR ("caller must be root.\n");
+               return -EPERM;
+       }
+       if (!inode) {
+               NBD_ERROR ("given bad inode.\n");
+               return -EINVAL;
+       }
+       if (major (inode->i_rdev) != major) {
+               NBD_ERROR ("pseudo-major %d != %d\n",
+                          major (inode->i_rdev), major);
+               return -ENODEV;
+       }
+       minor = minor (inode->i_rdev);
+       nbd = minor >> NBD_SHIFT;
+       if (nbd >= MAX_NBD) {
+               NBD_ERROR ("tried to open too many devices, %d\n", minor);
+               return -ENODEV;
+       }
+       lo = &nbd_dev[nbd];
+       lo->harderror = 0;
+       islot = minor % NBD_MAXCONN - 1;
+
+        /*
+         * PTB fixup breakage >= 2.5.44 caused by not being allowed to talk to
+         * minors. We deduce the slot number from hints in the call.
+         * Or we match against the known pids.
+         */
+        if (islot < 0) {
+                islot = fixup_slot(lo, islot, cmd, &arg);
+        }
+        if (islot >= 0)
+                slot = & lo->slots[islot];
+      
+
+       // PTB these are all always local ioctls
+       switch (cmd) {
+               int err;
+               int intval;
+                int do_reenable;
+
+         case NBD_CLEAR_SOCK:
+               if (islot < 0) {
+                       NBD_ALERT ("CLEAR_SOCK called on full device nd%s arg %lx\n",
+                                  lo->devnam, arg);
+                       return -EINVAL;
+                }
+               err = nbd_clr_sock (slot);
+               return err;
+
+         case NBD_SET_SOCK:
+               if (islot < 0) {
+                       NBD_ALERT ("SET_SOCK called on full device nd%s arg %lx\n",
+                               lo->devnam, arg);
+                       return -EINVAL;
+                }
+               err = nbd_set_sock (slot, arg);
+               return err;
+
+         case BLKBSZGET:
+                // PTB The kernel should intercept this
+               NBD_ALERT ("attempted get_blksize with BLKBSZGET\n");
+                return -EINVAL;
+
+          case NBD_GET_BLKSIZE:
+               if (!(atomic_read (&lo->flags) & NBD_BLKSIZED)) {
+                       return -EINVAL;
+               }
+               err = put_user (lo->blksize, (long *) arg);
+               return err;
+
+         case BLKBSZSET:
+                // PTB The kernel should have intercepted this
+               NBD_ALERT ("attempted set_blksize with BLKBSZSET\n");
+                return -EINVAL;
+
+          case NBD_SET_BLKSIZE:
+                if (!arg)
+                        return -EINVAL;
+               intval = -1;
+                if (get_user (intval, (int *)arg))
+                        return -EFAULT;
+               if (intval == -1) {
+                       NBD_ALERT ("BLKBSZSET got %d from user\n", intval);
+               }
+               err = nbd_set_blksize (lo, intval);
+               return err;
+
+         case NBD_SET_SIZE:
+               err = nbd_set_size (lo, (__u64) arg);
+               return err;
+
+         case NBD_SET_SECTORS:
+               err = nbd_set_size (lo, ((__u64) arg) << 9);
+               return err;
+
+         case MY_NBD_SET_INTVL:        /* WG */
+               err = nbd_set_intvl (lo, arg);
+               return err;
+
+         case MY_NBD_SET_SPID:
+               if (islot < 0) {
+                       NBD_ALERT ("SET_SPID called on full device nd%s\n",
+                                       lo->devnam);
+                       return -EINVAL;
+               }
+               err = nbd_set_spid (slot, arg);
+               return err;
+
+         case MY_NBD_SET_BUFFERWR:
+               err = nbd_set_bufferwr (lo, arg);
+               return err;
+
+         case MY_NBD_REG_BUF:  /* PTB register your buffer per socket here */
+               if (!arg) {
+                       /* PTB serves as existence check for this ioctl */
+                       return 0;
+               }
+               if (islot < 0) {
+                       NBD_ALERT ("REG_BUF called on full device nd%s\n",
+                                       lo->devnam);
+                       return -EINVAL;
+               }
+               err = nbd_reg_buf (slot, (char *) arg);
+               return err;
+
+         case MY_NBD_SET_SIG:
+               if (islot < 0) {
+                      NBD_ALERT ("SET_SIG called on full device nd%s\n",
+                          lo->devnam);
+                      return -EINVAL;
+               }
+               err = nbd_set_sig (slot, (int *) arg);
+               return err;
+
+         case MY_NBD_GET_REQ:
+               if (islot < 0) {
+                       NBD_ALERT ("GET_REQ called on full device nd%s\n",
+                           lo->devnam);
+                       return -EINVAL;
+               }
+                if (arg < 4096) {
+                    arg = (unsigned)slot->buffer;
+                    if (!arg)
+                        return -EINVAL;
+                }
+               err = nbd_get_req (slot);
+               return err;
+
+         case MY_NBD_GET_NPORT:
+               err = nbd_get_nport (lo, (int *) arg);
+               return err;
+
+         case MY_NBD_CLR_REQ:
+               if (islot < 0) {
+                       NBD_ALERT ("CLR_REQ called on full device nd%s\n",
+                                  lo->devnam);
+                       return -EINVAL;
+               }
+               nbd_rollback_all (slot);
+               return 0;
+
+         case MY_NBD_ERR_REQ:
+               if (islot < 0) {
+                       NBD_ALERT ("ERR_REQ called on full device nd%s\n",
+                                  lo->devnam);
+                       return -EINVAL;
+               }
+               nbd_error_all (slot);
+               return 0;
+
+         case MY_NBD_SYNC:
+
+                // PTB maybe run the reenable function
+                do_reenable = 0;
+                write_lock(&lo->meta_lock);
+                if (lo->reenable_time != 0
+                        && time_before(lo->reenable_time,jiffies)) {
+                        lo->reenable_time = 0;
+                        do_reenable = 1;
+                }
+                write_unlock(&lo->meta_lock);
+                if (do_reenable)
+                        nbd_reenable(lo);
+
+               // PTB error too old reqs if show_errs set, else roll them back
+               nbd_rollback_old (lo);
+
+                // PTB opportunity to calculate speed
+               nbd_set_speed (lo);
+
+               return 0;
+
+         case MY_NBD_ACK:
+               if (islot < 0) {
+                       NBD_ALERT ("NBD_ACK called on full device nd%s\n",
+                                  lo->devnam);
+                       return -EINVAL;
+               }
+               err = nbd_ack (slot);
+               return err;
+
+               /* let this be compiled in always - it's useful. PTB */
+         case NBD_PRINT_DEBUG:
+               NBD_INFO("device %d: hd = %p, tl = %p, in = %d, out = %d\n",
+                 minor,
+                  list_head (&lo->queue, struct request, queuelist),
+                 list_tail (&lo->queue, struct request, queuelist),
+                 atomic_read (&lo->requests_in[READ]) +
+                   atomic_read (&lo->requests_in[WRITE]),
+                 atomic_read (&lo->requests_out[READ]) +
+                   atomic_read (&lo->requests_out[WRITE])
+                  );
+               err = 0;
+               return err;
+         case NBD_HARD_RESET:  /* PTB - debugging */
+               err = nbd_hard_reset (lo);
+               return err;
+
+         case NBD_RESET:       /* PTB - debugging */
+               err = nbd_soft_reset (lo);
+               // PTB we reenable in 5s
+                nbd_reenable_delay(lo, 5);
+               return err;
+
+         case NBD_SET_MD5SUM:  /* PTB - change to do/plead md5summing */
+               if (arg) {
+                       atomic_set_mask (NBD_MD5SUM, &lo->flags);
+               } else {
+                       atomic_clear_mask (NBD_MD5SUM, &lo->flags);
+               }
+               err = 0;
+               return err;
+
+         case MY_NBD_SET_SHOW_ERRS:    /* PTB/WG - change show error status */
+               if (arg) {
+                       atomic_set_mask (NBD_SHOW_ERRS, &lo->flags);
+               } else {
+                       atomic_clear_mask (NBD_SHOW_ERRS, &lo->flags);
+               }
+               return 0;
+
+          case MY_NBD_SET_DIRECT:      /* PTB - change o_direct status */
+               if (arg) {
+                       atomic_set_mask (NBD_DIRECT, &lo->flags);
+               } else {
+                       atomic_clear_mask (NBD_DIRECT, &lo->flags);
+               }
+               return 0;
+
+         case MY_NBD_INVALIDATE:
+               err = nbd_set_remote_invalid (lo, (int) arg);
+               return err;
+
+         case NBD_SET_PF_MEMALLOC:
+               if (arg) {
+                       current->flags |= PF_MEMALLOC;
+               } else {
+                       current->flags &= ~PF_MEMALLOC;
+               }
+               return 0;
+        } // PTB endsw
+
+       // PTB these are the standard ioctls, and we might get them from
+       // the other side
+
+       switch (cmd) {
+               int err;
+                int intval;
+
+          case BLKROSET:               /* PTB - change ro status */
+                if (get_user(intval, (int*)arg))
+                        return -EFAULT;
+                // PTB local flags
+                nbd_set_read_only(lo, intval);
+               return 0;
+
+          case BLKROGET:
+                intval =  nbd_read_only(lo);
+                return put_user(intval, (int*)arg);
+
+         case BLKFLSBUF:
+               nbd_maybe_sync_sync (lo);       // PTB normally fsync_dev
+               // PTB device likely has buffers or caches in kernel
+               invalidate_buffers (inode->i_rdev);
+#ifndef NO_BUFFERED_WRITES
+               if (atomic_read (&lo->flags) & NBD_BUFFERWR) {
+                       // PTB got this from rd.c
+                        // PTB destroy buffers
+                       __invalidate_buffers (inode->i_rdev, 1);
+               }
+#endif         /* NO_BUFFERED_WRITES */
+               return 0;
+
+         case HDIO_GETGEO:
+               if (!arg) {
+                       return -EINVAL;
+               } else {
+                       struct hd_geometry *geo =
+                        (struct hd_geometry *) arg;
+                       int sectors = nbd_sizes[nbd << NBD_SHIFT] << 1;
+                       unsigned short c;
+                       unsigned char h, s;
+                       if (sectors < (1 << 22)) {
+                               h = 4;
+                               s = 16;
+                               c = sectors >> 6;
+                       } else {
+                               h = 255;
+                               s = 63;
+                               c = (sectors / h) / s;
+                       }
+                       err = 0;
+                       if ((err = put_user (c, &geo->cylinders), err < 0)
+                           || (err = put_user (h, &geo->heads), err < 0)
+                           || (err = put_user (s, &geo->sectors), err < 0)
+                           || (err = put_user (h, &geo->start), err < 0)) {
+                               return err;
+                       }
+               } 
+               return 0;
+
+#ifndef BLKMDNTFY
+#define BLKMDNTFY _IOW(0x12,133,sizeof(int))
+#endif
+              case BLKMDNTFY:
+                NBD_INFO ("received BLKMDNTFY, am now in raid %x\n",
+                        (unsigned) arg);
+                nbd_md.inc(&nbd_md);
+                return 0;
+
+#ifndef BLKMDUNTFY
+#define BLKMDUNTFY _IOW(0x12,134,sizeof(int))
+#endif
+              case BLKMDUNTFY:
+                NBD_INFO ("received BLKMDUNTFY, now out of raid %x\n",
+                        (unsigned) arg);
+                nbd_md.dec(&nbd_md);
+                return 0;
+
+#ifndef BLKMDRGTR
+#define BLKMDRGTR _IOW(0x12,135,sizeof(unsigned long))
+#endif
+              case BLKMDRGTR:
+                nbd_md.reg(&nbd_md, (int(*)(kdev_t, int))arg);
+                return 0;
+
+       } // PTB endsw
+
+        if (nbd_remote_ioctl.remote != NULL) {
+                struct nbd_ioctl *remote_ioctl = nbd_remote_ioctl.remote;
+
+               if (remote_ioctl->convert_inplace (&cmd) < 0) {
+                       NBD_ALERT ("unauthorized ioctl %#x\n", cmd);
+                       return -EINVAL;
+               }
+
+                err = do_nbd_remote_ioctl(lo, minor, cmd, arg);
+                return err;
+        } 
+        return -EINVAL;
+}
+
+/*
+ * PTB - release the device. This happens when the last process closes
+ * or dies.
+ */
+static int
+nbd_release (struct inode *inode, struct file *file)
+{
+       struct nbd_device *lo;
+       int dev;
+       int nbd;
+       int islot;
+
+       if (!inode) {
+               NBD_ALERT ("null inode.\n");
+               return -ENODEV;
+       }
+       dev = minor (inode->i_rdev);
+       nbd = dev >> NBD_SHIFT;
+
+       if (nbd >= MAX_NBD) {
+                // PTB impossible
+               NBD_ALERT ("too many open devices.\n");
+               return -ENODEV;
+       }
+
+       lo = &nbd_dev[nbd];
+
+       islot = dev % NBD_MAXCONN - 1;
+
+       // PTB it is a daemon closing the slot?
+        if (islot >= 0 || (islot = find_slot(lo, current->pid), islot >= 0)) {
+               struct nbd_slot *slot = &lo->slots[islot];
+               --slot->refcnt;
+               if (slot->pid == current->pid) {
+
+                       nbd_clr_sock (slot);
+                       NBD_ALERT ("(%d): erasing slot pid %d\n", islot, slot->pid);
+                       slot->pid = 0;
+                       if (slot->refcnt > 0) {
+                               NBD_ALERT
+                                ("slot owner process %d released slot nd%s%d while not last\n",
+                                 slot->pid, lo->devnam, islot + 1);
+                       }
+               }
+       }
+
+       /* POSSIBLE change socket here PTB */
+
+       atomic_dec (&lo->refcnt);
+
+       // PTB invalidate buffers on last close if show_err set
+       if (atomic_read (&lo->refcnt) <= 0 || !module_is_live(THIS_MODULE)) {
+                struct nbd_seqno * seqno_out = &lo->seqno_out;
+               //invalidate_buffers (lo->inode->i_rdev);     
+                if (atomic_read (&lo->flags) & NBD_SHOW_ERRS) {
+                       invalidate_buffers (mk_kdev (major, nbd << NBD_SHIFT));
+                }
+                // PTB in any case the daemons are dead!
+               lo->bufsiz = 0;
+               seqno_out->reset(seqno_out);
+       }
+
+        if (file
+        && (file->f_flags & O_DIRECT)
+        // PTB we set this to show we made iobuf
+        && (file->f_flags & O_NOFOLLOW))  {
+                file->f_flags &= ~(O_DIRECT|O_NOFOLLOW);
+        }
+
+        return 0;
+}
+
+static int
+nbd_media_changed(struct gendisk *disk) {
+        struct nbd_device *lo = disk->private_data;
+        if (!lo || lo->magic != NBD_DEV_MAGIC)
+                return 0;
+        NBD_ALERT("nbd_media_changed called on nd%s\n", lo->devnam);
+        return (atomic_read (&lo->flags) & NBD_VALIDATED) == 0;
+}
+
+static int
+nbd_revalidate(struct gendisk *disk) {
+        struct nbd_device *lo = disk->private_data;
+       unsigned long flags;
+        int err = -EINVAL;
+
+        if (!lo || lo->magic != NBD_DEV_MAGIC){
+                return -EINVAL;
+        }
+               // PTB reenable part
+        NBD_ALERT("revalidate called on nd%s\n", lo->devnam);
+        write_lock_irqsave (&lo->meta_lock, flags);
+        if (! (atomic_read (&lo->flags) & NBD_REMOTE_INVALID)
+                &&    (atomic_read (&lo->flags) & NBD_ENABLED)) {
+                atomic_set_mask (NBD_VALIDATED, &lo->flags);
+                err = 0;
+        }
+       write_unlock_irqrestore (&lo->meta_lock, flags);
+
+        return err;
+}
+
+static struct block_device_operations nbd_blkops = {
+        owner:                  THIS_MODULE,
+       open:                   nbd_open,
+       release:                nbd_release,
+       ioctl:                  nbd_ioctl,
+        media_changed:          nbd_media_changed,
+        revalidate_disk:        nbd_revalidate,
+};
+
+static struct gendisk *
+nbd_find (dev_t dev, int *part, void *data)
+{
+       struct nbd_device *lo = data;
+        if (!lo)
+                return NULL;
+       if (lo->magic != NBD_DEV_MAGIC)
+                return NULL;
+        if (!lo->disk)
+                return NULL;
+        if (part)
+                NBD_ALERT("nbd_find called with part = %#x\n", (unsigned)*part);
+        if (part && (*part < 0 || *part >= NBD_MAXCONN))
+                return NULL;
+       return get_disk (lo->disk);
+}
+
+
+static int
+nbd_set_disk (struct nbd_device *lo, unsigned first_minor, unsigned npart)
+{
+        struct gendisk * disk = lo->disk;
+       if (!disk)
+               lo->disk = disk = alloc_disk (npart);
+       if (disk) {
+               disk->major        = major;
+               disk->first_minor  = first_minor;
+               disk->fops         = &nbd_blkops;
+               disk->private_data = lo;
+               disk->queue        = lo->q;
+               sprintf (disk->disk_name, "nd%s", lo->devnam);
+                // have to set minors (or capacity) to 1 (0) to avoid check disk
+                set_capacity (disk, 0);
+               add_disk (disk);
+                blk_register_region(MKDEV(major, first_minor),
+                        npart, THIS_MODULE, nbd_find, NULL, lo);
+               set_capacity (disk, lo->bytesize >> 9);
+                // we should rescan later. From userland?
+                return 0;
+       }
+
+       NBD_ERROR ("Insufficient memory for partition structs\n");
+        return -ENOMEM;
+}
+
+/*
+ * Pavel - And here should be modules and kernel interface 
+ *  (Just smiley confuses emacs :-)
+ */
+
+
+static void
+nbd_reset(struct nbd_device *lo, int i) {
+
+        int j;
+
+        if (i < 0 || i >= MAX_NBD)
+            return;
+       lo->magic = NBD_DEV_MAGIC;
+       strncpy (lo->devnam, device_letter (i), 4);
+       for (j = 0; j < NBD_MAXCONN; j++) {     /* PTB */
+               struct nbd_slot *slot = &lo->slots[j];
+               slot->lo = lo;
+               slot->i = j;
+               INIT_LIST_HEAD (&slot->queue);
+       }
+       lo->blksize = 1024;     /* PTB 132 */
+       lo->logblksize = 10;    /* PTB */
+       lo->bytesize = 0x7fffffff00000; /* PTB 132 */
+       lo->size = 0x7fffffff;  /* PTB (bytesizes >> 10) */
+       lo->sectors = 0xfffffffe;       /* PTB sectors */
+       lo->nbd = i;
+       lo->req_timeo = NBD_REQ_TIMEO;  /* PTB default pulse intvl */
+       lo->max_sectors = buf_sectors;
+
+        lo->enable = nbd_enable;
+        lo->reset = nbd_reset;
+        lo->disable = nbd_disable;
+        lo->read_only = nbd_read_only;
+        lo->set_speed = nbd_set_speed;
+        lo->hard_reset = nbd_hard_reset;
+        lo->soft_reset = nbd_soft_reset;
+        lo->reenable_delay = nbd_reenable_delay;
+
+       INIT_LIST_HEAD (&lo->queue);
+       INIT_LIST_HEAD (&lo->altqueue);
+       init_waitqueue_head (&lo->wq);
+       init_waitqueue_head (&lo->req_wq);
+        init_MUTEX(&lo->pid_sem);
+       rwlock_init (&lo->queue_lock);
+       rwlock_init (&lo->altqueue_lock);
+       rwlock_init (&lo->meta_lock);
+       for (j = 0; j < NBD_MAXCONN; j++) {
+               nbd_blksizes[i * NBD_MAXCONN + j] = lo->blksize;
+               nbd_bytesizes[i * NBD_MAXCONN + j] = lo->bytesize;
+               nbd_sizes[i * NBD_MAXCONN + j] = lo->size;
+               nbd_max_sectors[i * NBD_MAXCONN + j] = lo->max_sectors;
+       }
+        nbd_init_seqno(&lo->seqno_out);
+        nbd_init_speed(&lo->rspeed);
+        nbd_init_speed(&lo->wspeed);
+        nbd_init_speed(&lo->tspeed);
+
+        // PTB queuue has alreay been initialized, or will be
+        lo->q = nbd_queue;
+
+       if (md5sum) {
+               atomic_set_mask (NBD_MD5SUM, &lo->flags);
+       }
+       if (sync_intvl) {
+               atomic_set_mask (NBD_SYNC, &lo->flags);
+       }
+       if (show_errs) {
+               atomic_set_mask (NBD_SHOW_ERRS, &lo->flags);
+       }
+        if (direct) {
+                atomic_set_mask (NBD_DIRECT, &lo->flags);
+        }
+       if (buffer_writes) {
+               atomic_set_mask (NBD_BUFFERWR, &lo->flags);
+       }
+        if (merge_requests) {
+                atomic_set(&lo->merge_requests, merge_requests);
+        }
+}
+
+#ifdef MODULE
+MODULE_AUTHOR ("Peter T. Breuer, Andres Marin");
+MODULE_DESCRIPTION ("Enhanced Network Block Device " NBD_VERSION);
+MODULE_LICENSE ("GPL");
+#endif         /* MODULE */
+
+// PTB we steal these from the queue struct at init
+static merge_requests_fn *ll_merge_requests_fn;
+static merge_request_fn *ll_front_merge_fn;
+static merge_request_fn *ll_back_merge_fn;
+
+/* PTB -
+ * These functions are needed when the kernel does request merging in
+ * order to stop it making requests that are bigger than our buffer.
+ *
+ * To turn OFF merging (once these functions are in place), set
+ * merge_requests=0.
+ */
+static int
+nbd_merge_requests_fn (request_queue_t * q, struct request *req,
+                      struct request *req2)
+{
+       struct nbd_device *lo = req->rq_disk->private_data;
+
+       if (!atomic_read(&lo->merge_requests))
+               return 0;
+
+       if (!ll_merge_requests_fn)
+               return 0;
+
+       if (req->nr_sectors + req2->nr_sectors > lo->max_sectors)
+               return 0;
+
+       if (req->nr_sectors + req2->nr_sectors >
+           ((atomic_read(&lo->merge_requests) + 1) << (lo->logblksize - 9)))
+               return 0;
+
+       return ll_merge_requests_fn (q, req, req2);
+}
+static int
+nbd_front_merge_fn (request_queue_t * q, struct request *req, struct bio * bio)
+{
+       struct nbd_device *lo = req->rq_disk->private_data;
+
+       if (!atomic_read(&lo->merge_requests))
+               return 0;
+
+       if (!ll_front_merge_fn)
+               return 0;
+
+       if (req->nr_sectors > lo->max_sectors)
+               return 0;
+
+       if (req->nr_sectors > ((atomic_read(&lo->merge_requests) + 1) << (lo->logblksize - 9)))
+                return 0;
+
+       return ll_front_merge_fn (q, req, bio);
+}
+static int
+nbd_back_merge_fn (request_queue_t * q, struct request *req,
+                  struct bio * bio)
+{
+       struct nbd_device *lo = req->rq_disk->private_data;
+
+       if (!atomic_read(&lo->merge_requests))
+               return 0;
+
+       if (!ll_back_merge_fn)
+               return 0;
+
+       if (req->nr_sectors > lo->max_sectors)
+               return 0;
+
+       if (req->nr_sectors >
+           ((atomic_read(&lo->merge_requests) + 1) << (lo->logblksize - 9))) return 0;
+
+        return ll_back_merge_fn (q, req, bio);
+}
+
+// PTB - and now to play with the sysctl interface ...
+static struct ctl_table_header *nbd_table_header;
+// the above was set by the register call of the root table
+static ctl_table nbd_table[] = {
+       {1, "rahead",
+        &rahead, sizeof (int), 0644, NULL, &proc_dointvec},
+       {2, "plug",
+        &plug, sizeof (int), 0644, NULL, &proc_dointvec},
+       {3, "sync_intvl",
+        &sync_intvl, sizeof (int), 0644, NULL, &proc_dointvec},
+       {4, "merge_requests",
+        &merge_requests, sizeof (int), 0644, NULL, &proc_dointvec},
+       {5, "md5sum",
+        &md5sum, sizeof (int), 0644, NULL, &proc_dointvec},
+       {8, "md5_on_threshold",
+        &md5_on_threshold, sizeof (int), 0644, NULL, &proc_dointvec},
+       {9, "md5_off_threshold",
+        &md5_off_threshold, sizeof (int), 0644, NULL, &proc_dointvec},
+       {0}
+};
+static ctl_table nbd_dir_table[] = {
+       {6, "enbd", NULL, 0, 0555, nbd_table},
+       {0}
+};
+static ctl_table nbd_root_table[] = {
+       {CTL_DEV, "dev", NULL, 0, 0555, nbd_dir_table},
+       {0}
+};
+
+#ifdef CONFIG_DEVFS_FS
+static devfs_handle_t devfs_handle;
+static devfs_handle_t devfs_handles[MAX_NBD];
+#endif
+
+
+int __init
+nbd_init (void)
+{
+       int i;
+       int err = 0;
+       struct proc_dir_entry *res;
+
+       NBD_INFO ("Network Block Device originally by pavel@elf.mj.gts.cz\n");
+       NBD_INFO ("Network Block Device port to 2.0 by ptb@it.uc3m.es\n");
+       NBD_INFO ("Network Block Device move networking to user space by "
+                 "amarin@it.uc3m.es\n");
+       NBD_INFO ("Enhanced Network Block Device " NBD_VERSION " by "
+                 "ptb@it.uc3m.es\n");
+
+        nbd_queue = kmalloc(sizeof(*nbd_queue), GFP_KERNEL);
+        if (!nbd_queue)
+            return -ENOMEM;
+
+        for (i = 0; i < MAX_NBD; i++) {
+               struct nbd_device *lo = &nbd_dev[i];
+                struct gendisk *disk = alloc_disk(NBD_MAXCONN);
+               memset (lo, 0, sizeof (*lo));
+                if (disk)
+                    lo->disk = disk;
+        }
+
+       if (register_blkdev (major, "nbd", &nbd_blkops)) {
+               NBD_ERROR ("Unable to register major number %d for NBD\n",
+                          major);
+               return -EIO;
+       }
+#ifdef MODULE
+       NBD_INFO ("registered device at major %d\n", major);
+#endif
+
+
+// PTB - set up kernel queue struct with default methods
+       blk_init_queue (nbd_queue, do_nbd_request, &nbd_lock);
+
+        blk_queue_max_sectors(nbd_queue, buf_sectors); /* max per request */
+
+/*
+ * PTB - I think that put:
+ *     - q->plug_device_fn    = generic_plug_device    (static ll_rw_blk)
+ *     - q->plug_tq.routine   = generic_unplug_device  (static ll_rw_blk)
+ *     - q->back_merge_fn     = ll_back_merge_fn       (static ll_rw_blk)
+ *     - q->front_merge_fn    = ll_front_merge_fn      (static ll_rw_blk)
+ *     - q->merge_requests_fn = ll_merge_requests_fn   (static ll_rw_blk)
+ *     - q->request_fn        = do_nbd_request         (param)
+ */
+
+/*
+ * PTB - we have to do some more init magic in 2.4.*. This says that we
+ *     - take all stuff off the kernel queue before processing it, so in
+ *     - particular iti s OK for kernel to do merges with the queue head.
+ *       blk_queue_headactive (nbd_queue, 0);
+ */
+
+/*
+ * LA - moved the next #if higher;
+ *    - kernel 2.2.* doesn't know about plug_device_fn
+ */
+
+       // PTB control merge attempts so we do not overflow our buffer
+       ll_merge_requests_fn = nbd_queue->merge_requests_fn;
+       ll_front_merge_fn    = nbd_queue->front_merge_fn;
+       ll_back_merge_fn     = nbd_queue->back_merge_fn;
+
+// JSA - Add this line because under >=2.4.1, merge optimizations are in flux
+/*
+ * PTB - however it's not this which does damage, I believe. Data: plugging
+ *     - simply has to be enabled in these kernels. Without it, requests just
+ *     - sit on the kernel queue and never come off and into our request_fn.
+ * PTB - commented the ifdef again after talks with Jens Axboe.
+ *     - Apparently plug_fn will disappear in 2.4.4 and merge functions are
+ *       the only way to control merges, so they MUST be included.
+ */
+
+/*
+ * PTB - The functions below just impose our own stricter size limit before
+ *     - calling the defaults if all seems OK sizewise.
+ */
+       nbd_queue->merge_requests_fn = &nbd_merge_requests_fn;
+       nbd_queue->front_merge_fn    = &nbd_front_merge_fn;
+       nbd_queue->back_merge_fn     = &nbd_back_merge_fn;
+
+        nbd_init_md(&nbd_md);
+        nbd_init_ioctl_stub(&nbd_remote_ioctl);
+
+        for (i = 0; i < MAX_NBD; i++) {
+               struct nbd_device *lo = &nbd_dev[i];
+                nbd_reset(lo, i);
+        }
+
+        /*
+         * PTB we do the disk and partition stuff after we have
+         * contact, when nbd_open is called for the first time?
+         */
+
+        res = create_proc_read_entry ("nbdinfo", 0, NULL, NULL, NULL);
+       if (!res) {
+               NBD_ALERT ("creation of proc entry failed\n");
+               return -EINVAL;
+       }
+       // PTB additional write_proc entry in struct
+        nbd_init_proc(res);
+
+        // PTB make the gendisk structs very late.
+        for (i = 0; i < MAX_NBD; i++) {
+               struct nbd_device *lo = &nbd_dev[i];
+                nbd_set_disk(lo, i * NBD_MAXCONN, NBD_MAXCONN);
+        }
+
+#ifdef CONFIG_DEVFS_FS
+
+       devfs_handle = devfs_mk_dir (NULL, "nd", NULL);
+       if (devfs_handle) {
+               for (i = 0; i < MAX_NBD; i++) {
+                       struct nbd_device *lo = &nbd_dev[i];
+                       int j;
+                       // PTB make the subdirectory "a","b" etc.
+                       devfs_handles[i] =
+                        devfs_mk_dir (devfs_handle, lo->devnam, NULL);
+                       // PTB add the blk specials, "0","1" to NBD_MAXCONN-1
+                       if (!devfs_handles[i])
+                                continue;
+                       for (j = 0; j < MAX_NBD; j++) {
+                               char name[4];
+                               sprintf (name, "%u", j);
+                                devfs_register(devfs_handles[i], name,
+                                        DEVFS_FL_DEFAULT,
+                                        major, i * NBD_MAXCONN + j,
+                                        S_IFBLK | S_IRUSR | S_IWUSR,
+                                        &nbd_blkops, NULL);
+                        }
+                       // PTB do the whole disk symlink ..
+                       devfs_mk_symlink (devfs_handles[i], "disk",
+                                         DEVFS_FL_DEFAULT, "0",
+                                         NULL, NULL);
+                       // PTB .. and the channel symlinks
+                       for (j = 1; j < MAX_NBD; j++) {
+                               char link[4];
+                               char name[8];
+                               sprintf (link, "%u", j);
+                               sprintf (name, "chan%u", j);
+                               devfs_mk_symlink (devfs_handles[i],
+                                                 name,
+                                                 DEVFS_FL_DEFAULT,
+                                                 link, NULL, NULL);
+                       }
+               }
+       }
+#endif         /* CONFIG_DEVFS_FS */
+
+       // PTB - sysctl interface
+       nbd_table_header = register_sysctl_table (nbd_root_table, 1);
+
+        // PTB we have to wait for the open to complete init with inode val
+
+       return err;
+}
+
+void __exit
+nbd_cleanup (void)
+{
+       int i;
+
+       for (i = 0; i < MAX_NBD; i++) {
+
+               struct nbd_device *lo = &nbd_dev[i];
+               int j;
+
+               if (!(atomic_read (&lo->flags) & NBD_INITIALISED))
+                       continue;
+
+               NBD_INFO ("invalidating buffers on device nd%s%d-%d\n",
+                         lo->devnam, 0, NBD_MAXCONN);
+
+               for (j = 0; j < NBD_MAXCONN; j++) {
+                       int minor = i * NBD_MAXCONN + j;
+                       invalidate_buffers (mk_kdev (major, minor));
+               }
+
+               NBD_INFO ("destroying buffers on device nd%s%d-%d\n",
+                         lo->devnam, 0, NBD_MAXCONN);
+
+               for (j = 0; j < NBD_MAXCONN; j++) {
+                       int minor = i * NBD_MAXCONN + j;
+                       __invalidate_buffers (mk_kdev (major, minor), 1);
+               }
+       }
+
+       unregister_sysctl_table (nbd_table_header);
+
+#ifdef CONFIG_DEVFS_FS
+       if (devfs_handle) {
+               for (i = 0; i < MAX_NBD; i++) {
+                       int j;
+                       if (!devfs_handles[i])
+                               continue;
+                       for (j = 0; j < NBD_MAXCONN; j++) {
+                               char s[3];
+                               s[0] = '0' + j;
+                               s[1] = 0;
+                               if (j >= 10) {
+                                       s[0] = '1';
+                                       s[1] = '0' + (j - 10);
+                                       s[2] = 0;
+                               }
+                               devfs_remove("nd/%s/%u", device_letter(i), j);
+                                if (j == 0) {
+                                       devfs_remove("nd/%s/disk", device_letter(i));
+                                } else {
+                                       devfs_remove("nd/%s/chan%u",device_letter(i),j);
+                                }
+                       }
+                       devfs_remove("nd/%s", device_letter(i));
+               }
+               devfs_remove("nd");
+       }
+#endif
+
+       remove_proc_entry ("nbdinfo", &proc_root);
+
+       for (i = 0; i < MAX_NBD; i++) {
+               struct nbd_device *lo = &nbd_dev[i];
+               atomic_clear_mask (NBD_ENABLED, &lo->flags);
+                if (lo->disk) {
+                    del_gendisk(lo->disk);
+                    put_disk(lo->disk);
+                }
+               if (lo->blockmap) {
+                       kfree (lo->blockmap);
+                       lo->blockmap = NULL;
+               }
+               nbd_sync_sync (lo);
+       }
+
+       blk_cleanup_queue (nbd_queue);
+
+       if (unregister_blkdev (major, "nbd") != 0) {
+               NBD_ALERT ("cleanup_module failed\n");
+       } else {
+               NBD_INFO ("module cleaned up.\n");
+       }
+        kfree(nbd_queue);
+        
+}
+
+module_init (nbd_init);
+module_exit (nbd_cleanup);
+
+EXPORT_SYMBOL(nbd_remote_ioctl);
+
+/* Compile line:
+
+ *  gcc -O2 -D__KERNEL__ -DMODULE -DEXPORT_SYMTAB -xc -c enbd.c -o enbd.o
+ *
+ *  (possibly with -DMODVERSIONS also). PTB
+ *  (possibly with -I/usr/src/linux-x.y.z/include also). PTB
+ */
--- linux-2.5.64/drivers/block/enbd/enbd_ioctl.c.pre-enbd       Mon Mar 24 18:55:25 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_ioctl.c        Tue Mar 25 15:45:03 2003
@@ -0,0 +1,405 @@
+#ifndef __KERNEL__
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+#include <linux/ioctl.h>
+#include <linux/fs.h>
+#include <linux/fd.h>
+#ifndef _CADDR_T
+#define caddr_t char*
+#endif
+#include <linux/cdrom.h>
+#include <asm/uaccess.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/init.h>
+#ifndef KERNEL_VERSION
+#define KERNEL_VERSION(a,b,c)  (((a) << 16) + ((b) << 8) + (c))
+#endif
+#include <linux/blk.h>
+#include <linux/enbd.h>
+#include <linux/enbd_ioctl.h>
+
+
+/*
+ * This is the whitelist of remote ioctls - an entry here tells the
+ * driver that it's OK to send this ioctl out over the net, because we
+ * have the right info on it.
+ *
+ * "The right info" is what is on the right hand side of the table (a 0
+ * stands for a repetition of the LHS info). We have to fixup something
+ * that a lot of kernel authors forgot to do or got worng - namely
+ * declare their ioctls in a way that conveys information about their
+ * intended mode of use (see iotcl.h in the kernel sources).
+ *
+ * We need all ioctls to be delared as either
+ *
+ *    _IO(class,id)         -- default. Means no args. The call is enough.
+ *    _IOW(class,id,type)   -- we write a value to kernel that is sizeof(type)
+ *    _IOR(class,id,type)   -- we read a value from kernel sizeof(type)
+ *    _IOWR(class,id,type)  -- ibid, but both ways
+ *
+ *  The "R" bit is crucial because it lets us know that the data is
+ *  _indirected_. I.e. it's an address of somewhere in userspace where
+ *  we want to read data from or write data to. 
+ *
+ *  The "type" part should be the type of the indirected argument, NOT
+ *  the type of its address!
+ *
+ *  Kernel authors typically make two mistakes:
+ *
+ *     1) they write _IO instead of _IOR or IOWR, and hence forget the
+ *        type info. Well, not telling me if the argument data is
+ *        direct or indirectly accessible was already bad enough!
+ *     2) they get the type argument _wrong_ when they do remember to
+ *        put it. They write "int *" instead  of "int", for example,
+ *        when the argument to the ioctl is a pointer to an integer.
+ *        OK, so it's a natural mistake to make! But in that case the
+ *        argument should be "int" so that the kernel macro picks up
+ *        sizeof(int) instead of sizeof(int*).
+ *
+ *  Those "errors" have to be repaired via this table. Wrong at left,
+ *  corrected at right. A 0 for the new entry indicates that the old
+ *  was alright. If there isn't an entry, the ioctl won't be treated.
+ *  If the size info works out at the max for the field  (2^14 - 1)
+ *  then a extra table is consulted for size and copy methods.
+ */
+
+
+/*
+ * PTB the space before the final comma is important as the ##
+ * discards the preceding token when D is empty
+ */
+#define _NEW_IO_(B,C,D...) C(_IOC_TYPE(B), _IOC_NR(B) , ## D)
+#define _NEW_IO(B,D...)   _IO(_IOC_TYPE(B), _IOC_NR(B) , ## D)
+#define _NEW_IOW(B,D...)  _IOW(_IOC_TYPE(B), _IOC_NR(B) , ## D)
+#define _NEW_IOR(B,D...)  _IOR(_IOC_TYPE(B), _IOC_NR(B) , ## D)
+#define _NEW_IOWR(B,D...) _IOWR(_IOC_TYPE(B), _IOC_NR(B) , ## D)
+#define _NEW_IORS(B) _IOC(_IOC_READ,_IOC_TYPE(B), _IOC_NR(B), _IOC_SIZEMASK)
+#define _NEW_IOWRS(B) _IOC(_IOC_READ|_IOC_WRITE,_IOC_TYPE(B), _IOC_NR(B), _IOC_SIZEMASK)
+
+static struct ioctl_conv ioctl_conv_tab[] = {
+// fs.h
+   { BLKROSET, _NEW_IOW(BLKROSET,int), },
+   { BLKROGET, _NEW_IOR(BLKROGET,int), },
+//#define BLKRRPART  _IO(0x12,95) /* re-read partition table */
+   { BLKRRPART,  0, },
+   { BLKGETSIZE, _NEW_IOR(BLKGETSIZE,int), },
+//#define BLKFLSBUF  _IO(0x12,97) /* flush buffer cache */
+   { BLKFLSBUF,  0, },
+   { BLKRASET,   _NEW_IOW(BLKRASET,int), },
+   { BLKRAGET,   _NEW_IOR(BLKRAGET,int), },
+   { BLKFRASET,  _NEW_IOW(BLKFRASET,int), },
+   { BLKFRAGET,  _NEW_IOR(BLKFRAGET,int), },
+   { BLKSECTSET, _NEW_IOW(BLKSECTSET,int), },
+   { BLKSECTGET, _NEW_IOR(BLKSECTGET,int), },
+   { BLKSSZGET,  _NEW_IOR(BLKSSZGET,int), },
+//  fd.h
+   { FDCLRPRM,  0, },
+   { FDSETPRM, _NEW_IOWR(FDSETPRM, struct floppy_struct), },
+   { FDDEFPRM, _NEW_IOWR(FDDEFPRM, struct floppy_struct), }, 
+   { FDGETPRM, _NEW_IOR(FDGETPRM, struct floppy_struct), }, 
+   { FDMSGON,   0, }, 
+   { FDMSGOFF,  0, }, 
+   { FDFMTBEG,  0, }, 
+   { FDFMTTRK, _NEW_IOWR(FDFMTTRK, struct format_descr), }, 
+   { FDFMTEND,  0, }, 
+   { FDSETEMSGTRESH, _NEW_IOW(FDSETEMSGTRESH, unsigned), }, 
+   { FDFLUSH,  0, }, 
+   { FDSETMAXERRS, _NEW_IOWR(FDSETMAXERRS, struct floppy_max_errors), }, 
+   { FDGETMAXERRS, _NEW_IOR(FDGETMAXERRS, struct floppy_max_errors), }, 
+   { FDGETDRVTYP, _NEW_IOR(FDGETDRVTYP, floppy_drive_name), }, // 16 bytes
+   { FDSETDRVPRM, _NEW_IOWR(FDSETDRVPRM, struct floppy_drive_params), }, 
+   { FDGETDRVPRM, _NEW_IOR(FDGETDRVPRM, struct floppy_drive_params), }, 
+   { FDGETDRVSTAT, _NEW_IOR(FDGETDRVSTAT, struct floppy_drive_struct), }, 
+   { FDPOLLDRVSTAT, _NEW_IOR(FDPOLLDRVSTAT, struct floppy_drive_struct), }, 
+   { FDRESET,  0, }, 
+   { FDGETFDCSTAT, _NEW_IOR(FDGETFDCSTAT, struct floppy_fdc_state), }, 
+   { FDWERRORCLR,  0, }, 
+   { FDWERRORGET, _NEW_IOR(FDWERRORGET, struct floppy_write_errors), }, 
+   { FDRAWCMD, _NEW_IOWR(FDRAWCMD, struct floppy_raw_cmd[1]) },  // FIXME linked list
+   { FDTWADDLE,  0, }, 
+   { FDEJECT,  0, }, 
+// cdrom.h
+   { CDROMPAUSE, _NEW_IO(CDROMPAUSE), }, 
+   { CDROMRESUME, _NEW_IO(CDROMRESUME), }, 
+   { CDROMPLAYMSF, _NEW_IOR(CDROMPLAYMSF, struct cdrom_msf), }, 
+   { CDROMPLAYTRKIND, _NEW_IOR(CDROMPLAYTRKIND, struct cdrom_ti), }, 
+   { CDROMREADTOCHDR, _NEW_IOWR(CDROMREADTOCHDR, struct cdrom_tochdr), }, 
+   { CDROMREADTOCENTRY, _NEW_IOWR(CDROMREADTOCENTRY, struct cdrom_tocentry), }, 
+   { CDROMSTOP, _NEW_IO(CDROMSTOP), }, 
+   { CDROMSTART, _NEW_IO(CDROMSTART), }, 
+   { CDROMEJECT, _NEW_IO(CDROMEJECT), }, 
+   { CDROMVOLCTRL, _NEW_IOR(CDROMVOLCTRL, struct cdrom_volctrl), }, 
+   { CDROMSUBCHNL, _NEW_IOWR(CDROMSUBCHNL, struct cdrom_subchnl), }, 
+   { CDROMREADMODE2, _NEW_IOR(CDROMREADMODE2, struct cdrom_read), },  // INDIRECT 2336B
+   { CDROMREADMODE1, _NEW_IOR(CDROMREADMODE1, struct cdrom_read), },  // INDIRECT 2048B
+   { CDROMREADAUDIO, _NEW_IOR(CDROMREADAUDIO, struct cdrom_read_audio), }, 
+   { CDROMEJECT_SW, _NEW_IO(CDROMEJECT_SW), }, 
+   { CDROMMULTISESSION, _NEW_IOWR(CDROMMULTISESSION, struct cdrom_multisession), }, 
+   { CDROM_GET_MCN, _NEW_IOWR(CDROM_GET_MCN, struct cdrom_mcn), }, 
+   { CDROMRESET, _NEW_IO(CDROMRESET), }, 
+   { CDROMVOLREAD, _NEW_IOWR(CDROMVOLREAD, struct cdrom_volctrl), }, 
+   { CDROMREADRAW, _NEW_IOR(CDROMREADRAW, struct cdrom_read), },  // INDIRECT 2352B
+   // aztcd.c optcd.c
+   { CDROMREADCOOKED, _NEW_IOR(CDROMREADCOOKED, struct cdrom_msf), }, // INDIRECT FIXME
+   { CDROMSEEK, _NEW_IOR(CDROMSEEK, struct cdrom_msf), }, 
+   // scsi-cd.c
+   { CDROMPLAYBLK, _NEW_IOWR(CDROMPLAYBLK, struct cdrom_blk), }, 
+   // optcd.c
+   { CDROMREADALL, _NEW_IOR(CDROMREADALL, char[2646]), }, 
+   // ide-cd.c
+   { CDROMGETSPINDOWN, _NEW_IOWR(CDROMGETSPINDOWN, char), },  // one byte
+   { CDROMSETSPINDOWN, _NEW_IOWR(CDROMSETSPINDOWN, char), },  // one byte
+   // cdrom.c
+   { CDROMCLOSETRAY, _NEW_IO(CDROMCLOSETRAY), },
+   { CDROM_SET_OPTIONS, _NEW_IOW(CDROM_SET_OPTIONS, int), },
+   { CDROM_CLEAR_OPTIONS, _NEW_IOW(CDROM_CLEAR_OPTIONS, int), },
+   { CDROM_SELECT_SPEED, _NEW_IOW(CDROM_SELECT_SPEED, int), }, // FIXME 
+   { CDROM_SELECT_DISC, _NEW_IOW(CDROM_SELECT_DISC, int), },
+   { CDROM_MEDIA_CHANGED, _NEW_IOW(CDROM_MEDIA_CHANGED, int), },
+   { CDROM_DRIVE_STATUS, _NEW_IOW(CDROM_DRIVE_STATUS, int), },
+   { CDROM_DISC_STATUS, _NEW_IO(CDROM_DISC_STATUS), },
+   { CDROM_CHANGER_NSLOTS, _NEW_IO(CDROM_CHANGER_NSLOTS), },
+   { CDROM_LOCKDOOR, _NEW_IOW(CDROM_LOCKDOOR, int), },
+   { CDROM_DEBUG, _NEW_IOW(CDROM_DEBUG, int), },
+   { CDROM_GET_CAPABILITY, _NEW_IO(CDROM_GET_CAPABILITY), },
+   // sbpcd
+   { CDROMAUDIOBUFSIZ, _NEW_IOW(CDROMAUDIOBUFSIZ, int), },
+   // dvd
+   { DVD_READ_STRUCT, _NEW_IOR(DVD_READ_STRUCT, dvd_struct), },
+   { DVD_WRITE_STRUCT, _NEW_IOWR(DVD_WRITE_STRUCT, dvd_struct), },
+   { DVD_AUTH, _NEW_IOWR(DVD_AUTH, dvd_authinfo), },
+   { CDROM_SEND_PACKET, _NEW_IOR(CDROM_SEND_PACKET, struct cdrom_generic_command), },
+   { CDROM_NEXT_WRITABLE, _NEW_IOWR(CDROM_NEXT_WRITABLE, long), },
+   { CDROM_LAST_WRITTEN, _NEW_IOWR(CDROM_LAST_WRITTEN, long), },
+   // PTB local test ioctls
+   { NBD_TEST_IOCTL1, 0, },   // write an int
+   { NBD_TEST_IOCTL2, 0, },   // read an int
+   { NBD_TEST_IOCTL3, 0, },   // write and read an int
+   { NBD_TEST_IOCTL4, 0, },   // read 256B
+   { NBD_TEST_IOCTL5, 0, },   // r/w 256B
+   { NBD_TEST_IOCTL6, _NEW_IORS(NBD_TEST_IOCTL6), },    // read special
+   { NBD_TEST_IOCTL7, _NEW_IORS(NBD_TEST_IOCTL7), },    // r/w special
+   // PTB we must terminate with a 0,0 entry.
+   {0 , 0, },
+};
+
+/*
+ * This should be the table of special methods for certain ioctls.
+ * The "new" code is the real index. It will have a size count of
+ * _IOC_SIZEMASK but the rest of it should be meaningful. The size is
+ * gotten by dynamic lookup using the size() function.
+ */
+static struct ioctl_special ioctl_special_tab[] = {
+    // PTB last entry must be all zeros
+    { 0, NULL, NULL, NULL, NULL, },
+};
+
+
+static struct ioctl_conv *
+ioctl_lookup_old (int ioctl)
+{
+       int i;
+        unsigned old;
+        if (ioctl == -1)
+            return NULL;
+       for (i = 0; old = ioctl_conv_tab[i].old, old; i++) {
+               if (old == ioctl)
+                       return &ioctl_conv_tab[i];
+       }
+       // PTB not there
+       return NULL;
+}
+
+int
+nbd_ioctl_convert (int ioctl)
+{
+       struct ioctl_conv *conv = ioctl_lookup_old (ioctl);
+       if (!conv)
+               // PTB not there
+               return -1;
+        return conv->new ? : ioctl;
+}
+
+int
+nbd_ioctl_convert_inplace(int *ioctl) {
+
+       int new_ioctl;
+       if (!ioctl)
+           return -EINVAL;
+       new_ioctl = nbd_ioctl_convert(*ioctl);
+       if (new_ioctl == -1)
+           return -EINVAL;
+       *ioctl = new_ioctl;
+       return 0;
+}
+
+static struct ioctl_conv *
+ioctl_lookup_new (int ioctl)
+{
+       int i = 0;
+       unsigned old;
+       for (i = 0; old = ioctl_conv_tab[i].old, old; i++) {
+               unsigned new = ioctl_conv_tab[i].new;
+               if (new == ioctl || (new == 0 && old == ioctl)) 
+                       return &ioctl_conv_tab[i];
+       }
+       // PTB not there
+       return NULL;
+}
+
+int
+nbd_ioctl_revert (int ioctl)
+{
+       struct ioctl_conv *conv = ioctl_lookup_new (ioctl);
+       if (!conv)
+               // PTB not there
+               return -1;
+       return conv->old;
+}
+
+static struct ioctl_special *
+ioctl_special_lookup_new (int ioctl)
+{
+       int i;
+        unsigned new;
+       for (i = 0; new = ioctl_special_tab[i].new, new; i++) {
+               if (new == ioctl) 
+                       return &ioctl_special_tab[i];
+       }
+       // PTB not there
+       return NULL;
+}
+
+int
+nbd_ioctl_size (int cmd, char *arg)
+{
+       int size = _IOC_SIZE (cmd);
+       if (size == _IOC_SIZEMASK) {
+               // PTB special hadling required. 
+                struct ioctl_special *special = ioctl_special_lookup_new(cmd);
+                if (!special)
+                        return -1;
+               return special->size (arg);
+       }
+       return size;
+}
+
+int
+nbd_ioctl_size_user (int cmd, char *arg)
+{
+       int size = _IOC_SIZE (cmd);
+       if (size == _IOC_SIZEMASK) {
+               // PTB special hadling required. 
+                struct ioctl_special *special = ioctl_special_lookup_new(cmd);
+                if (!special)
+                        return -1;
+               return special->size_user (arg);
+       }
+       return size;
+}
+
+
+#ifdef __KERNEL__
+int
+nbd_ioctl_copy_to_user (int cmd, char *arg, char *buf, int size)
+{
+
+       if (_IOC_SIZE (cmd) == _IOC_SIZEMASK) {
+                struct ioctl_special *special = ioctl_special_lookup_new(cmd);
+                if (!special)
+                        return -1;
+               return special->ioctl_copy_to_user (arg, buf, size);
+       }
+
+       if (_IOC_DIR (cmd) & _IOC_READ) {
+               // indirect
+               copy_to_user (arg, buf, size);
+               return size;
+       }
+
+       return -1;
+}
+
+
+
+int
+nbd_ioctl_copy_from_user (int cmd, char *buf, char *arg, int size)
+{
+
+       if (_IOC_SIZE (cmd) == _IOC_SIZEMASK) {
+                struct ioctl_special *special = ioctl_special_lookup_new(cmd);
+                if (!special)
+                        return -1;
+               return special->ioctl_copy_from_user (buf, arg, size);
+       }
+
+       if (_IOC_DIR (cmd) & _IOC_READ) {
+               // indirect
+               copy_from_user (buf, arg, size);
+               return size;
+       }
+
+       // direct
+       if (size > sizeof (arg)) {
+               return -1;
+       }
+
+       memcpy (buf, &arg, size);
+       return size;
+}
+
+static struct nbd_ioctl struct_ioctl = {
+        convert : nbd_ioctl_convert,
+        convert_inplace : nbd_ioctl_convert_inplace,
+        revert  : nbd_ioctl_revert,
+        size    : nbd_ioctl_size,
+        size_user : nbd_ioctl_size_user,
+        cp_to_user : nbd_ioctl_copy_to_user,
+        cp_from_user : nbd_ioctl_copy_from_user,
+};
+
+static int __init
+nbd_ioctl_init (void)
+{
+    struct nbd_ioctl_stub * remote_ioctl = &nbd_remote_ioctl;
+    remote_ioctl->reg(remote_ioctl, &struct_ioctl);
+    return 0;
+}
+
+static void __exit
+nbd_ioctl_cleanup (void) {
+    struct nbd_ioctl_stub * remote_ioctl = &nbd_remote_ioctl;
+    remote_ioctl->unreg(remote_ioctl, &struct_ioctl);
+}
+
+module_init (nbd_ioctl_init);
+module_exit (nbd_ioctl_cleanup);
+
+int linux_version_code = LINUX_VERSION_CODE;
+
+#ifdef MODULE
+  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,0)
+    MODULE_AUTHOR ("Peter T. Breuer");
+    MODULE_DESCRIPTION ("Enhanced Network Block Device Remote Ioctl");
+    #ifdef MODULE_LICENSE
+      MODULE_LICENSE("GPL");
+    #endif
+  #endif
+#endif         /* MODULE */
+
+#endif /* __KERNEL__ */
+
+
+/*
+static
+int ioctl_init(struct ioctl_conv *self, int old, int new) {
+    self->old = old;
+    self->new = new;
+    self->serialize = ioctl_serialize;
+    self->deserialize = ioctl_deserialize;
+    self->size = ioctl_size;
+}
+*/
--- linux-2.5.64/drivers/block/enbd/enbd_ioctl_stub.c.pre-enbd  Mon Mar 24 18:55:25 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_ioctl_stub.c   Mon Mar 24 22:51:59 2003
@@ -0,0 +1,30 @@
+
+#include <linux/stddef.h>
+#include <linux/errno.h>
+#include <linux/enbd.h>
+#include <linux/enbd_ioctl.h>
+
+  /*
+   * PTB this is the hook for the enbd_ioctl extra module
+   */
+  static int register_remote_ioctl(struct nbd_ioctl_stub *remote_ioctl, struct nbd_ioctl *x) {
+          if (!remote_ioctl->remote) {
+                remote_ioctl->remote = x;
+                return 0;
+          }
+          return -EINVAL;
+  }
+  static int unregister_remote_ioctl(struct nbd_ioctl_stub *remote_ioctl, struct nbd_ioctl *x) {
+        if (remote_ioctl->remote != x)
+                return -EINVAL;
+        remote_ioctl->remote = NULL;
+        return 0;
+  }
+
+int nbd_init_ioctl_stub(struct nbd_ioctl_stub *remote_ioctl) {
+        memset(remote_ioctl, 0, sizeof(*remote_ioctl));
+        remote_ioctl->reg = register_remote_ioctl;
+        remote_ioctl->unreg = unregister_remote_ioctl;
+        return 0;
+}
+
--- linux-2.5.64/drivers/block/enbd/enbd_md.c.pre-enbd  Mon Mar 24 18:55:25 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_md.c   Mon Mar 24 22:51:59 2003
@@ -0,0 +1,99 @@
+#include <linux/enbd.h>
+#include <linux/enbd_ioctl.h>
+
+/*
+ * PTB small driver wide support database for MDRGTR ioctl
+ */
+
+
+
+#ifndef HOT_ADD_DISK
+  #define HOT_ADD_DISK          _IO (MD_MAJOR, 0x28)
+#endif
+#ifndef SET_DISK_FAULTY
+  #define SET_DISK_FAULTY       _IO (MD_MAJOR, 0x29)
+#endif
+
+static void
+nbd_md_dec (struct nbd_md *md) {
+        down(&md->access_sem);
+        if (--md->count <= 0)
+                md->notify_fn = NULL;
+        up(&md->access_sem);
+}
+static void
+nbd_md_inc (struct nbd_md *md) {
+        down(&md->access_sem);
+        md->count++;
+        up(&md->access_sem);
+}
+static void
+nbd_md_reg (struct nbd_md *md, int(*fn)(kdev_t, int)) {
+        down(&md->access_sem);
+        if (!md->notify_fn) {
+                md->notify_fn = fn;
+                md->count++;
+        }
+        up(&md->access_sem);
+}
+
+/*
+ * PTB tell md devices in which we are embedded that we are alright
+ *
+ *   @lo the nbd device to tell them about
+ */
+static int
+nbd_notify_md_devices (struct nbd_md *md, kdev_t nbd_dev)
+{
+       //kdev_t nbd_dev = mk_kdev (major, nbd << NBD_SHIFT);
+        int err;
+
+       down (&md->access_sem);
+       if (md->count > 0 && md->notify_fn) {
+               NBD_ALERT ("adding %x:%x to raid devices via fn\n",
+                        major(nbd_dev), minor(nbd_dev));
+               err = md->notify_fn (nbd_dev, HOT_ADD_DISK);
+               if (err < 0) {
+                       NBD_ALERT ("HOT_ADD to raid devices returned %d\n",
+                                err);
+               }
+       }
+       up (&md->access_sem);
+
+       return 0;
+}
+
+static int
+nbd_unnotify_md_devices (struct nbd_md *md, kdev_t nbd_dev)
+{
+
+       // kdev_t nbd_dev = mk_kdev (major, lo->nbd << NBD_SHIFT);
+        int err;
+
+       down (&md->access_sem);
+       if (md->count > 0 && md->notify_fn) {
+               NBD_ALERT ("erasing %x:%x from raid devices via fn\n",
+                          major(nbd_dev), minor(nbd_dev));
+               err = md->notify_fn (nbd_dev, SET_DISK_FAULTY);
+               if (err < 0) {
+                       NBD_ALERT
+                        ("SETFAULTY to raid devices returned %d\n", err);
+               }
+       }
+       up (&md->access_sem);
+        return 0;
+}
+
+void
+nbd_init_md(struct nbd_md *md)
+{
+        md->notify_fn = NULL;
+        md->count = 0;
+        init_MUTEX(&md->access_sem);
+        md->notify = nbd_notify_md_devices;
+        md->unnotify = nbd_unnotify_md_devices;
+        md->dec = nbd_md_dec;
+        md->inc = nbd_md_inc;
+        md->reg = nbd_md_reg;
+}
+
--- linux-2.5.64/drivers/block/enbd/enbd_seqno.c.pre-enbd       Mon Mar 24 18:55:25 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_seqno.c        Mon Mar 24 23:28:41 2003
@@ -0,0 +1,75 @@
+#include <linux/enbd.h>
+
+
+#define _NBD_GENERATION (8*sizeof(int) - __REQ_NBDSEQNO)
+/*
+ * PTB increment the devices seqno
+ *
+ *  @lo the nbd device to increment the seqno of
+ */
+static void
+seqno_inc(struct nbd_seqno *nseqno)
+{
+       if (nseqno->seqno < (1 << _NBD_GENERATION)) {
+               ++nseqno->seqno;
+                return;
+        } 
+        // PTB next generation !
+       nseqno->seqno = 0;
+       atomic_inc (&nseqno->seqno_gen);
+}
+static int
+seqno_get (struct nbd_seqno *nseqno)
+{
+        return nseqno->seqno;
+}
+static void
+seqno_reset (struct nbd_seqno *nseqno)
+{
+        nseqno->seqno = 0;
+       atomic_set(&nseqno->seqno_gen,0);
+}
+/*
+ * PTB convert a seqno number into one with an extra generation number
+ * in the msb, so that it can be compared with others. return the
+ * result.
+ *
+ * We add the current generation no. to small seqnos, and we add the
+ * previous generation no. to large seqnos.
+ *
+ *   @lo the nbd device to look at
+ *   @seqno the small sequence number to return the full seq number for
+ */
+static unsigned int
+seqno_calc (struct nbd_seqno *nseqno, unsigned int seqno)
+{
+        unsigned int genno;
+        static unsigned int absdiff(unsigned int x, unsigned int y) {
+            if (x > y) {
+                return x - y;
+            } else {
+                return y - x;
+            }
+        };
+        genno = atomic_read (&nseqno->seqno_gen);
+       if (absdiff(seqno,nseqno->seqno) < (1 << (_NBD_GENERATION - 1))) {
+               return seqno + (genno << _NBD_GENERATION);
+       }
+        if (seqno < nseqno->seqno) {
+               return seqno + ((genno + 1) << _NBD_GENERATION);
+        } 
+        return seqno + ((genno - 1) << _NBD_GENERATION);
+}
+
+void nbd_init_seqno (struct nbd_seqno *nseqno) {
+
+        seqno_reset(nseqno);
+
+        nseqno->inc   = seqno_inc;
+        nseqno->get   = seqno_get;
+        nseqno->reset = seqno_reset;
+        nseqno->calc  = seqno_calc;
+}
+
+
+
--- linux-2.5.64/drivers/block/enbd/enbd_speed.c.pre-enbd       Mon Mar 24 18:55:25 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_speed.c        Mon Mar 24 23:28:50 2003
@@ -0,0 +1,64 @@
+#include <linux/enbd.h>
+#include <linux/enbd_ioctl.h>
+
+/*
+ * PTB - update speed counters (if at least 5s has passed)
+ *
+ *  @spd the speed struct to update
+ */
+static void
+spd_update (struct nbd_speed *spd, int distance)
+{
+
+       // last time we measured
+       int lastjiffy = atomic_read (&spd->jiffy);
+       // jiffies since last time
+       int djiffy = jiffies - lastjiffy;
+
+       // previous no we measured
+       int lastdist = atomic_read (&spd->distance);
+       // blocks since last time
+       int ddistance = distance - lastdist;
+
+       // write every 5 second in time
+       if (djiffy > 5 * HZ) {
+
+               // jiffies since first time
+               int tjiffy = jiffies - atomic_read (&spd->frstj);
+
+               // max tot speed measured so far
+               int speedmax = atomic_read (&spd->speedmax);
+
+               // last instantaneous speed we measured
+               int lastspeed = atomic_read (&spd->speed);
+
+               // instantaneous read blocks/s
+               int speed = djiffy ? (ddistance * HZ) / djiffy : 0;
+
+               // smoothed KB/s
+               int speedsmoothed =
+                (djiffy * speed + HZ * lastspeed) / (djiffy + HZ);
+
+               // average speed to now in KB/s
+               int speedav = tjiffy ? (distance * HZ) / tjiffy : 0;
+
+               // smoothing count for max
+               int speedhi =
+                (speedav > speedsmoothed) ? speedav : speedsmoothed;
+
+               // doing settings
+               atomic_set (&spd->speed, speedsmoothed);
+               if (speedhi > speedmax)
+                       atomic_set (&spd->speedmax, speedhi);
+               atomic_set (&spd->distance, distance);
+               atomic_set (&spd->speedav, speedav);
+               atomic_set (&spd->jiffy, jiffies);
+       }
+}
+
+void
+nbd_init_speed(struct nbd_speed *spd) {
+        memset(spd, 0, sizeof(*spd));
+        spd->update = spd_update;
+}
+
--- linux-2.5.64/drivers/block/enbd/enbd_proc.c.pre-enbd        Tue Mar 25 15:16:33 2003
+++ linux-2.5.64/drivers/block/enbd/enbd_proc.c Mon Mar 24 22:52:00 2003
@@ -0,0 +1,1059 @@
+
+#include <linux/enbd.h>
+#include <linux/proc_fs.h>
+
+extern struct nbd_device * nbd_get(int i);
+
+static void
+do_reset (int reset, int i) {
+
+       void do_r (void) {
+               struct nbd_device *lo = nbd_get(i);
+               if (reset != 0) {
+                       lo->reset (lo, i);
+                       return;
+               };
+       };
+       if (i >= 0 && i < MAX_NBD) {
+               do_r ();
+               return;
+       }
+}
+
+/*
+ * PTB This is just to get a nice limited width integer printout in proc!
+ * use endpos (<= 8) spaces at most. We serve from a static buffer size 16.
+ */
+char *
+display (unsigned n, int endpos)
+{
+       // PTB  use endpos (<= 8) spaces at most
+       static char buf[16];
+       int units = 0;
+       int decimals = 0;
+       int decpos = endpos;
+       int wholepart = n, fractionpart = 0;
+       buf[endpos--] = 0;
+       // PTB  find the right units to display. U or K or M or G.
+       while (n >= 1 << 10) {
+               decimals = n & ((1 << 10) - 1);
+               n >>= 10;
+               units++;
+       }
+       switch (units) {
+         case 0:
+               break;
+         case 1:
+               buf[endpos--] = 'K';
+               break;
+         case 2:
+               buf[endpos--] = 'M';
+               break;
+         case 3:
+               buf[endpos--] = 'G';
+               break;
+         case 4:
+               buf[endpos--] = 'T';
+               break;
+       }
+       // after this wholepart = n && fractionpart = decimals
+       fractionpart = wholepart & ((1 << (units * 10)) - 1);
+       wholepart >>= units * 10;
+       // PTB  write the whole digits (something between 0 and 1023 inclusive)
+       if (n == 0) {
+               buf[endpos--] = '0';
+       } else {
+               while (endpos >= 0 && n > 0) {
+                       buf[endpos--] = '0' + n % 10;
+                       n /= 10;
+               }
+       }
+       // PTB if there is space and cause, add decimal digits
+       if (endpos >= 1 && units > 0) {
+               int k = 0;
+               char unitchar = buf[--decpos];
+               buf[decpos + k++] = '.';
+               while (endpos >= k) {
+                       int digit = (decimals * 10) >> 10;
+                       buf[decpos + k++] = '0' + digit;
+                       decimals -= (digit << 10) / 10;
+                       decimals *= 10;
+               }
+               buf[decpos + k++] = unitchar;
+               buf[decpos + k] = 0;
+       }
+       // PTB report the start position
+       return buf + endpos + 1;
+}
+
+
+static void
+set_generic (int x, int i, int X)
+{
+       void set_x (void) {
+               struct nbd_device *lo = nbd_get(i);
+                if (lo->magic != NBD_DEV_MAGIC)
+                        return;
+               if (x != 0) {
+                       atomic_set_mask (X, &lo->flags);
+                       return;
+               };
+                atomic_clear_mask (X, &lo->flags);
+       };
+
+       if (i >= 0 && i < MAX_NBD) {
+               set_x ();
+               return;
+       }
+       for (i = 0; i < MAX_NBD; i++) {
+               set_x ();
+       }
+}
+
+static void
+set_sync_intvl (int sync_intvl, int i)
+{
+    set_generic(sync_intvl, i, NBD_SYNC);
+}
+
+
+static void
+set_show_errs (int show_errs, int i)
+{
+    set_generic(show_errs, i, NBD_SHOW_ERRS);
+}
+
+static void
+set_md5sum (int md5sum, int i)
+{
+    set_generic(md5sum, i, NBD_MD5SUM);
+}
+
+
+static void
+set_enable (int enable, int i)
+{
+       void set_e (void) {
+               struct nbd_device *lo = nbd_get(i);
+                if (!lo || lo->magic != NBD_DEV_MAGIC)
+                        return;
+               if (enable != 0) {
+                        if (!(atomic_read (&lo->flags) & NBD_ENABLED)) {
+                               lo->enable (lo);
+                               return;
+                        }
+               };
+                lo->disable (lo);
+       };
+
+       if (i >= 0 && i < MAX_NBD) {
+               set_e ();
+               return;
+       }
+       for (i = 0; i < MAX_NBD; i++) {
+               set_e ();
+       }
+}
+
+static void
+set_direct (int direct, int i)
+{
+        set_generic(direct, i, NBD_DIRECT);
+}
+
+#ifndef NO_BUFFERED_WRITES
+static void
+set_buffer_writes (int buffer_writes, int i)
+{
+        set_generic(buffer_writes, i, NBD_BUFFERWR);
+}
+#endif
+
+static void
+set_merge_requests (int mr, int i)
+{
+       void set_mr (void) {
+               struct nbd_device *lo = nbd_get(i);
+               if (lo->magic != NBD_DEV_MAGIC)
+                        return;
+                atomic_set (&lo->merge_requests, mr);
+       }
+        
+        if (i >= 0 && i < MAX_NBD) {
+               set_mr ();
+               return;
+       }
+       for (i = 0; i < MAX_NBD; i++) {
+               set_mr ();
+       }
+}
+
+int
+nbd_read_proc (char *buf, char **start, off_t offset, int len, int *eof,
+              void *data)
+{
+
+#ifndef MIN
+#define MIN(x,y) ((x)<(y)?(x):(y))
+#endif
+
+       const int limit = MIN (PAGE_SIZE, len) - 80;
+       static int i;
+       struct nbd_device *lo;
+       static int last;
+       static void *next_label;
+       static char *next_label_name;
+       static int total;
+       unsigned long flags;
+
+       if (offset > 0 && !next_label) {
+               *eof = 1;
+               *start = buf;
+               return 0;
+       }
+
+       if (offset <= 0) {
+               // PTB do static inits first time through
+               last = -1;
+               i = 0;
+               next_label = NULL;
+               next_label_name = NULL;
+               total = 0;
+       }
+
+       // PTB  start this bytecount
+       len = 0;
+
+#define NBD_PROC_LABEL(n) \
+        next_label = &&label_##n; \
+        next_label_name = "label_" #n; \
+        if (len > limit) { \
+            *start = (char *) (unsigned long) len; \
+            total += len; \
+            return len;\
+        } \
+        label_##n:
+
+       for ( /* static init */ ; i < MAX_NBD; i++) {
+
+               char *devnam;
+
+               lo = nbd_get(i);
+               devnam = lo->devnam;
+               if (lo->nslot <= 0) {
+                       next_label = NULL;
+                       continue;
+               }
+
+               // PTB computed goto next not-done
+               if (next_label) {
+                       void *label = next_label;
+                       next_label = NULL;
+                       next_label_name = NULL;
+                       len = 0;
+                       goto *label;
+               }
+
+               NBD_PROC_LABEL (1);
+
+               if (last == i - 2) {
+                        struct nbd_device * lo = nbd_get (i - 1);
+                       char *prevdevnam = lo->devnam;
+                       len +=
+                        sprintf (buf + len, "Device %s:\tClosed\n",
+                                 prevdevnam);
+               }
+               if (last < i - 2) {
+                        struct nbd_device * llo = nbd_get (last + 1);
+                        struct nbd_device * plo = nbd_get (i - 1);
+                       char lastdevnam[3];
+                       char prevdevnam[3];
+                       strncpy (lastdevnam, llo->devnam, 3);
+                       strncpy (prevdevnam, plo->devnam, 3);
+                       len +=
+                        sprintf (buf + len, "Device %s-%s:\tClosed\n",
+                                 lastdevnam, prevdevnam);
+               }
+
+               NBD_PROC_LABEL (2);
+
+               len +=
+                sprintf (buf + len, "Device %s:\tOpen " "\n", devnam);
+
+               NBD_PROC_LABEL (3);
+
+               len += sprintf (buf + len,
+                               "[%s] State:\t%s%s%s%s%s%s%s%s%s%s%s%slast error %d, lives %d, bp %d\n",
+                               devnam, atomic_read (&lo->flags)
+                               & NBD_INITIALISED ? "" : "uninitialized, ",
+                               atomic_read (&lo->flags)
+                               & NBD_WRITE_NOCHK ? "noverify, " :
+                               "verify, ", lo->read_only(lo) ? "ro, " : "rw, ",
+                               atomic_read(&lo->merge_requests) ? "merge requests, " : "",
+#ifndef NO_BUFFERED_WRITES
+                               atomic_read (&lo->flags)
+                               & NBD_BUFFERWR ? "buffer writes, " : "",
+#else
+                               "",
+#endif         /* NO_BUFFERED_WRITES */
+                               atomic_read (&lo->flags)
+                               & NBD_ENABLED ? "enabled, " : "disabled, ",
+                               atomic_read (&lo->flags)
+                               & NBD_VALIDATED ? "validated, " : "",
+                                atomic_read (&lo->flags)
+                               & NBD_REMOTE_INVALID ? "remote invalid, " : "",
+                               atomic_read (&lo->flags)
+                               & NBD_SHOW_ERRS ? "show_errs, " : "",
+                               atomic_read (&lo->flags)
+                                & NBD_DIRECT ? "direct, " : "",
+                               atomic_read (&lo->flags)
+                               & NBD_SYNC ? "sync, " : "",
+                               atomic_read (&lo->flags)
+                               & NBD_MD5SUM ? "md5sum, " : "",
+                               lo->harderror,
+                               lo->lives -
+                               ((atomic_read (&lo->flags) & NBD_ENABLED) ?
+                                1 : 0), 0      //atomic_read(&buffermem_pages)
+                );
+
+               NBD_PROC_LABEL (4);
+
+               do {            // PTB begin long do once block
+                       int countq[2] = { 0, 0 };
+                       int cmd;
+
+                       struct list_head *pos;
+
+                       read_lock_irqsave (&lo->queue_lock, flags);
+
+                       list_for_each (pos, &lo->queue) {
+                               struct request *req =
+                                list_entry (pos, struct request, queuelist);
+                               if (countq[READ] + countq[WRITE] > 1000)
+                                       break;
+
+                               cmd = rq_data_dir (req);
+                               countq[cmd]++;
+                       }
+
+                       read_unlock_irqrestore (&lo->queue_lock, flags);
+
+                       len += sprintf (buf + len,
+                                       "[%s] Queued:\t+%dR/%dW curr (check %dR/%dW) +%dR/%dW max\n",
+                                       devnam,
+                                       atomic_read (&lo->countq[READ]),
+                                       atomic_read (&lo->countq[WRITE]),
+                                       countq[READ], countq[WRITE],
+                                       atomic_read (&lo->maxq[READ]),
+                                       atomic_read (&lo->maxq[WRITE]));
+               } while (0);    // PTB end long do once block
+
+               NBD_PROC_LABEL (5);
+
+               len += sprintf (buf + len,
+                               "[%s] Buffersize:\t%d\t(sectors=%d, blocks=%d)\n",
+                               devnam, lo->bufsiz, lo->max_sectors,
+                               lo->max_sectors / (lo->blksize >> 9));
+               len +=
+                sprintf (buf + len, "[%s] Blocksize:\t%d\t(log=%d)\n",
+                         devnam, lo->blksize, lo->logblksize);
+               len +=
+                sprintf (buf + len, "[%s] Size:\t%luKB\n", devnam,
+                         (unsigned long) (lo->bytesize >> 10));
+               len +=
+                sprintf (buf + len, "[%s] Blocks:\t%u\n", devnam,
+                         lo->size >> (lo->logblksize - 10));
+
+               NBD_PROC_LABEL (6);
+
+               len +=
+                sprintf (buf + len, "[%s] Sockets:\t%d", devnam,
+                         lo->nslot);
+
+               NBD_PROC_LABEL (7);
+
+               do {            // PTB begin short do once block
+                       int j;
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               if (j != atomic_read (&lo->islot)) {
+                                       len +=
+                                        sprintf (buf + len, "\t(%s)",
+                                                 slotj->file ? "+" : "-");
+                                } else {
+                                       len +=
+                                        sprintf (buf + len, "\t(%s)",
+                                                 slotj->file ? "*" : ".");
+                                }
+                       }
+               } while (0);    // PTB end short do once block
+
+               len += sprintf (buf + len, "\n");
+
+               NBD_PROC_LABEL (8);
+
+               len += sprintf (buf + len, "[%s] Requested:\t%s", devnam,
+                               display (atomic_read
+                                        (&lo->requests_in[READ]) +
+                                        atomic_read (&lo->requests_in
+                                                     [WRITE]), 7));
+
+               NBD_PROC_LABEL (9);
+
+               do {            // PTB begin short do once block
+                       int j;
+                       char buff[2][8];
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               len +=
+                                sprintf (buf + len, "\t(%s)",
+                                         display (slotj->in, 5));
+                       }
+                       strncpy (buff[0],
+                                display (atomic_read
+                                         (&lo->requests_in[READ]), 6), 7);
+                       strncpy (buff[1],
+                                display (atomic_read
+                                         (&lo->requests_in[WRITE]), 6),
+                                7);
+                       len +=
+                        sprintf (buf + len, "\t%sR/%sW", buff[0],
+                                 buff[1]);
+                       lo->set_speed (lo);
+                       len += sprintf (buf + len, "\tmax %d",
+                                       atomic_read (&lo->maxreqblks));
+               } while (0);    // PTB end short do once block
+
+               len += sprintf (buf + len, "\n");
+               len += sprintf (buf + len, "[%s] Despatched:\t%s", devnam,
+                               display (atomic_read
+                                        (&lo->requests_out[READ]) +
+                                        atomic_read (&lo->requests_out
+                                                     [WRITE]), 7));
+
+               NBD_PROC_LABEL (10);
+
+               do {            // PTB begin short do once block
+                       int j;
+                       char buff[2][8];
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               len +=
+                                sprintf (buf + len, "\t(%s)",
+                                         display (slotj->out, 5));
+                       }
+                       strncpy (buff[0],
+                                display (atomic_read
+                                         (&lo->requests_out[READ]), 6),
+                                7);
+                       strncpy (buff[1],
+                                display (atomic_read
+                                         (&lo->requests_out[WRITE]), 6),
+                                7);
+                       len +=
+                        sprintf (buf + len, "\t%sR/%sW", buff[0],
+                                 buff[1]);
+                       len +=
+                        sprintf (buf + len, "\tmd5 %sW",
+                                 display (atomic_read
+                                          (&lo->wrequests_5to), 5));
+                       len +=
+                        sprintf (buf + len, " (%s eq,",
+                                 display (atomic_read
+                                          (&lo->wrequests_5so), 5));
+                       len +=
+                        sprintf (buf + len, " %s ne,",
+                                 display (atomic_read
+                                          (&lo->wrequests_5wo), 5));
+                       len +=
+                        sprintf (buf + len, " %s dn)",
+                                 display (atomic_read
+                                          (&lo->wrequests_5eo), 5));
+               } while (0);    // PTB end short do once block
+
+               len += sprintf (buf + len, "\n");
+               len += sprintf (buf + len, "[%s] Errored:\t%s", devnam,
+                               display (atomic_read (&lo->requests_err),
+                                        7));
+
+               NBD_PROC_LABEL (11);
+
+               do {            // PTB begin short do once block
+                       int j;
+                       char buff[2][8];
+                       int toterrs = 0;
+
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               len +=
+                                sprintf (buf + len, "\t(%s)",
+                                         display (slotj->err, 5));
+                               toterrs += slotj->err;
+                       }
+                       strncpy (buff[0], display (toterrs, 6), 7);
+                       strncpy (buff[1],
+                                display (atomic_read (&lo->requests_err) -
+                                         toterrs, 6), 7);
+                       len +=
+                        sprintf (buf + len, "\t%s+%s\n", buff[0],
+                                 buff[1]);
+               } while (0);    // PTB end short do once block
+
+               NBD_PROC_LABEL (12);
+
+               do {            // PTB begin long do once block
+                       int pending_rblks = 0;  /* PTB  reads not reached the slots yet */
+                       int pending_wblks = 0;  /* PTB  writes not reached the slots yet */
+                       int blks = 0;
+
+                       read_lock_irqsave (&lo->queue_lock, flags);
+
+                       do {    // PTB begin short do once block
+                               struct list_head *pos;
+
+                               int count = 0;
+                               struct request *req;
+
+                               list_for_each (pos, &lo->queue) {
+                                       req =
+                                        list_entry (pos, struct request,
+                                                    queuelist);
+                                       if (count++ > 1000)
+                                               break;
+                                       blks = req->nr_sectors / lo->blksize;
+                                       if (blks > 0) {
+                                               switch (rq_data_dir (req)) {
+                                                 case READ:
+                                                       pending_rblks +=
+                                                        blks;
+                                                       break;
+                                                 case WRITE:
+                                                       pending_wblks +=
+                                                        blks;
+                                                       break;
+                                               }
+                                       }
+                               }
+                       } while (0);    // PTB end short do once block
+
+                       read_unlock_irqrestore (&lo->queue_lock, flags);
+                       len +=
+                        sprintf (buf + len, "[%s] Pending:\t%d", devnam,
+                                 atomic_read (&lo->requests_req[READ]) +
+                                 atomic_read (&lo->requests_req[WRITE]));
+
+                       do {    // PTB begin short do once block
+                               int j;
+                               for (j = 0; j < lo->nslot; j++) {
+                                       struct nbd_slot *slotj =
+                                        &lo->slots[j];
+                                       len +=
+                                        sprintf (buf + len, "\t(%d)",
+                                                 slotj->req);
+                               }
+                       } while (0);    // PTB end short do once block
+
+                       len += sprintf (buf + len,
+                                       "\t%dR/%dW+%dR/%dW\n",
+                                       atomic_read (&lo->requests_req[READ]),
+                                       atomic_read (&lo->requests_req[WRITE]),
+                                       pending_rblks, pending_wblks);
+
+               } while (0);    // PTB end long do once block
+
+               NBD_PROC_LABEL (13);
+
+               do {            // PTB begin long do once block
+                       char buff[10][8];
+                       int shift = lo->logblksize;
+
+                       strncpy (buff[0],
+                                display (atomic_read (&lo->wspeed.speed)
+                                         << shift, 5), 7);
+                       strncpy (buff[1],
+                                display (atomic_read (&lo->wspeed.speedav)
+                                         << shift, 5), 7);
+                       strncpy (buff[2],
+                                display (atomic_read
+                                         (&lo->wspeed.speedmax) << shift,
+                                         5), 7);
+
+                       strncpy (buff[3],
+                                display (atomic_read (&lo->rspeed.speed)
+                                         << shift, 5), 7);
+                       strncpy (buff[4],
+                                display (atomic_read (&lo->rspeed.speedav)
+                                         << shift, 5), 7);
+                       strncpy (buff[5],
+                                display (atomic_read
+                                         (&lo->rspeed.speedmax) << shift,
+                                         5), 7);
+
+                       strncpy (buff[6],
+                                display (atomic_read (&lo->tspeed.speed)
+                                         << shift, 5), 7);
+                       strncpy (buff[7],
+                                display (atomic_read (&lo->tspeed.speedav)
+                                         << shift, 5), 7);
+                       strncpy (buff[8],
+                                display (atomic_read
+                                         (&lo->tspeed.speedmax) << shift,
+                                         5), 7);
+
+                       len +=
+                        sprintf (buf + len, "[%s] B/s now:", devnam);
+                       len +=
+                        sprintf (buf + len, "\t%s\t(%sR+%sW)\n", buff[6],
+                                 buff[3], buff[0]);
+                       len +=
+                        sprintf (buf + len, "[%s] B/s ave:", devnam);
+                       len +=
+                        sprintf (buf + len, "\t%s\t(%sR+%sW)\n", buff[7],
+                                 buff[4], buff[1]);
+                       len +=
+                        sprintf (buf + len, "[%s] B/s max:", devnam);
+                       len +=
+                        sprintf (buf + len, "\t%s\t(%sR+%sW)\n", buff[8],
+                                 buff[5], buff[2]);
+               } while (0);    // PTB end long do once block
+
+               do {            // PTB begin short do once block
+                       int blks;
+                       int tot_reqs = 0;
+
+                       len +=
+                        sprintf (buf + len, "[%s] Spectrum:", devnam);
+                       for (blks = 0;
+                            blks <= atomic_read (&lo->maxreqblks); blks++) {
+                               tot_reqs +=
+                                atomic_read (&lo->req_in[READ][blks]) +
+                                atomic_read (&lo->req_in[WRITE][blks]);
+                       }
+
+                       for (blks = 0;
+                            blks <= atomic_read (&lo->maxreqblks); blks++) {
+                               int req_blks =
+                                atomic_read (&lo->req_in[READ][blks])
+                                + atomic_read (&lo->req_in[WRITE][blks]);
+                               int percent =
+                                tot_reqs >
+                                0 ? (100 * req_blks) / tot_reqs : 0;
+                               if (percent <= 0)
+                                       continue;
+                               len +=
+                                sprintf (buf + len, "\t%u%%%d", percent,
+                                         blks);
+                       }
+                       len += sprintf (buf + len, "\n");
+               } while (0);    // PTB end short do once block
+
+               NBD_PROC_LABEL (14);
+
+               len += sprintf (buf + len, "[%s] Kthreads:\t%d", devnam,
+                               atomic_read (&lo->kthreads));
+               len +=
+                sprintf (buf + len, "\t(%d waiting/%d running/%d max)\n",
+                         atomic_read (&lo->kwaiters),
+                         atomic_read (&lo->kthreads) -
+                         atomic_read (&lo->kwaiters),
+                         atomic_read (&lo->kmax));
+
+               NBD_PROC_LABEL (15);
+
+               len += sprintf (buf + len, "[%s] Cthreads:\t%d", devnam,
+                               atomic_read (&lo->cthreads));
+
+               NBD_PROC_LABEL (16);
+
+               do {
+                       int j;
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               int state =
+                                ((slotj->flags & NBD_SLOT_RUNNING) ? 1 :
+                                 0) +
+                                ((slotj->flags & NBD_SLOT_WAITING) ? 2 :
+                                 0);
+                               char *desc = "?";
+                               switch (state) {
+                                 case 0:
+                                       desc = "-";
+                                       break;  /* PTB not in */
+                                 case 1:
+                                       desc = "*";
+                                       break;  /* PTB in and not waiting */
+                                 case 2:
+                                       desc = "?";
+                                       break;  /* PTB impossible */
+                                 case 3:
+                                       desc = "+";
+                                       break;  /* PTB in and waiting */
+                               }
+                               len += sprintf (buf + len, "\t(%s)", desc);
+                       }
+               } while (0);
+
+               len += sprintf (buf + len, "\n");
+
+               NBD_PROC_LABEL (17);
+
+               last = i;
+               len += sprintf (buf + len, "[%s] Cpids:\t%d", devnam,
+                               atomic_read (&lo->cthreads));
+
+               do {
+                       int j;
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               len +=
+                                sprintf (buf + len, "\t(%u)", slotj->pid);
+                       }
+                       len += sprintf (buf + len, "\n");
+               } while (0);
+
+               do {
+                       int j, k;
+                       for (j = 0; j < lo->nslot; j++) {
+                               struct nbd_slot *slotj = &lo->slots[j];
+                               if (slotj->spid != 0)
+                                       break;
+                       }
+                       if (j < lo->nslot) {
+                               len +=
+                                sprintf (buf + len, "[%s] Kpids:\t%d",
+                                         devnam,
+                                         atomic_read (&lo->cthreads));
+                               for (k = 0; k < lo->nslot; k++) {
+                                       struct nbd_slot *slotk =
+                                        &lo->slots[k];
+                                       len +=
+                                        sprintf (buf + len, "\t(%u)",
+                                                 slotk->spid);
+                               }
+                               len += sprintf (buf + len, "\n");
+                       }
+               } while (0);
+
+               NBD_PROC_LABEL (18);
+
+               NBD_PROC_LABEL (19);
+
+               // PTB have to tell loop head that we are not reentering 
+               next_label = NULL;
+               next_label_name = NULL;
+       }
+
+       NBD_PROC_LABEL (20);
+
+       if (last == i - 2) {
+                struct nbd_device * lo = nbd_get (i - 1);
+               char *prevnam = lo->devnam;
+               len +=
+                sprintf (buf + len, "Device %s:\tClosed\n", prevnam);
+       }
+
+       if (last < i - 2) {
+               char lastnam[3];
+               char prevnam[3];
+                struct nbd_device * llo = nbd_get (last + 1);
+                struct nbd_device * plo = nbd_get (i - 1);
+               strncpy (lastnam, llo->devnam, 3);
+               strncpy (prevnam, plo->devnam, 3);
+               len += sprintf (buf + len, "Device %s-%s:\tClosed\n",
+                               lastnam, prevnam);
+       }
+
+       NBD_PROC_LABEL (21);
+
+       // PTB re-init vital statistics for next time 
+       next_label = NULL;
+       next_label_name = NULL;
+
+       *eof = 1;
+       *start = buf;
+       total += len;
+
+       return len;
+}
+
+/*
+ * PTB read an int from a string. Return number of ints read (0 or 1).
+ */
+static int
+sscani (char *buf, int len, int *n)
+{
+
+       int i, a = 0;
+       short has_digits = 0;
+       short is_signed = 0;
+
+       // PTB look for first significant character
+       for (i = 0; i < len; i++) {
+               char c = buf[i];
+               if (c == ' ' || c == '\t') {
+                       if (is_signed)
+                               return 0;
+               } else if (c == '-') {
+                       if (is_signed)
+                               return 0;
+                       is_signed = -1;
+               } else if (c == '+') {
+                       if (is_signed)
+                               return 0;
+                       is_signed = 1;
+               } else if (c >= '0' && c <= '9') {
+                       is_signed = 1;
+                       has_digits = 1;
+                       break;
+               } else {
+                       return 0;
+               }
+       }
+       // PTB i now points at first digit if there is one
+       if (!has_digits)
+               return 0;
+       for (; i < len; i++) {
+               char c = buf[i];
+               if (c < '0' || c > '9')
+                       break;
+               a *= 10;
+               a += c - '0';
+       }
+       if (is_signed >= 0) {
+               *n = a;
+        } else {
+               *n = -a;
+        }
+       return 1;
+}
+
+/*
+ * look for a 1 or 2 letter device code ("a" or "aa") and save the
+ * device number to which it refers. Return number of device letter
+ * codes found (0 or 1).
+ */
+static int
+sscana (char *buf, int len, int *n)
+{
+
+       int i, a = 0;
+       short has_letters = 0;
+
+       for (i = 0; i < len; i++) {
+               char c = buf[i];
+               if (c >= 'a' && c <= 'z') {
+                       has_letters = 1;
+                       break;
+               } else if (c == ' ') {
+                       if (has_letters)
+                               return 0;
+               } else {
+                       return 0;
+               }
+       }
+       if (!has_letters)
+               return 0;
+       for (; i < len; i++) {
+               char c = buf[i];
+               if (c < 'a' || c > 'z')
+                       break;
+               a *= 26;
+               a += c - 'a';
+       }
+       *n = a;
+       return 1;
+}
+
+/*
+ * read an integer (or 2-letter ascii) arg into an int. Return numner
+ * of integers read (0 or 1) and -1 for no keymatch. The first arg is a
+ * preceding key.
+ * @i is the integer value that results
+ * @j is an index if one one supplied (foo[j] = i ), else -1
+ */
+static int
+getarg (const char *buffer, int buflen, const char *key, int *i, int *j)
+{
+
+       int keylen;
+
+       void skip_ws (void) {
+               while (buflen > 0) {
+                       if (*buffer != ' ' && *buffer != '\t')
+                               break;
+                       buffer++;
+                       buflen--;
+               }
+        };
+
+        skip_ws ();
+
+       keylen = strlen (key);
+       if (strncmp (buffer, key, keylen))
+               return -1;
+
+       buffer += keylen;
+       buflen -= keylen;
+
+       skip_ws ();
+
+       *j = -1;
+       if (*buffer == '[') {
+               char *closing;
+               int indexlen;
+
+               buffer++;
+               buflen--;
+
+               skip_ws ();
+
+               closing = strchr (buffer, ']');
+               if (!closing)
+                       return -1;
+               indexlen = closing - buffer;
+               *closing = 0;
+
+               if (sscani ((char *) buffer, indexlen, j) < 1)
+                       return 0;
+               if (sscana ((char *) buffer, buflen, j) < 1)
+                       return 0;
+
+               buffer = closing;
+               buflen -= indexlen;
+
+               buffer++;
+               buflen--;
+
+               skip_ws ();
+       }
+
+       if (*buffer != '=')
+               return -1;
+
+       buffer++;
+       buflen--;
+
+       skip_ws ();
+
+       if (sscani ((char *) buffer, buflen, i) < 1)
+               return 0;
+       if (sscana ((char *) buffer, buflen, i) < 1)
+               return 0;
+       return 1;
+}
+
+/*  
+ * PTB - write a 0 with echo -n 0 to /proc/nbdinfo to do a hard reset.
+ */
+static int
+nbd_write_proc (struct file *file, const char *buffer, unsigned long count,
+               void *data)
+{
+
+       switch (count) {
+
+               int i;
+
+         case 2:
+               if (buffer[1] != '\n')
+                       break;
+               /* else fallthru to case 1 */
+         case 1:
+               switch (*buffer) {
+                 case '1':
+                       for (i = 0; i < MAX_NBD; i++) {
+                               struct nbd_device *lo = nbd_get(i);
+                               lo->hard_reset (lo);
+                       }
+                       break;
+                 case '0':
+                       for (i = 0; i < MAX_NBD; i++) {
+                               //  PTB this takes the io spinlock and our spinlock.
+                               struct nbd_device *lo = nbd_get(i);
+                               lo->soft_reset (lo);
+                                lo->reenable_delay(lo, 5);
+                       }
+                       break;
+               }
+               break;
+         default:
+               do {
+                       int index;
+                        int merge_requests;
+                        int sync_intvl;
+                        int show_errs;
+                        int md5sum;
+#ifndef NO_BUFFERED_WRITES
+                        int buffer_writes;
+#endif
+                        int enable;
+                        int direct;
+                        int reset;
+
+                       if (getarg (buffer, count, "merge_requests",
+                                   &merge_requests, &index) >= 0) {
+                               // merge_requests
+                               set_merge_requests (merge_requests, index);
+                               break;
+                       }
+                       if (getarg (buffer, count, "sync_intvl",
+                                   &sync_intvl, &index) >= 0
+                           || getarg (buffer, count, "sync",
+                                      &sync_intvl, &index) >= 0) {
+                               // sync_intvl
+                               set_sync_intvl (sync_intvl, index);
+                               break;
+                       }
+                       if (getarg (buffer, count, "show_errs",
+                                   &show_errs, &index) >= 0) {
+                               // show_errs
+                               set_show_errs (show_errs, index);
+                               break;
+                       }
+                       if (getarg (buffer, count, "md5sum",
+                                   &md5sum, &index) >= 0) {
+                               // md5sum
+                               set_md5sum (md5sum, index);
+                               break;
+                       }
+#ifndef NO_BUFFERED_WRITES
+                       if (getarg (buffer, count, "buffer_writes",
+                                   &buffer_writes, &index) >= 0) {
+                               // buffer_writes
+                               set_buffer_writes (buffer_writes, index);
+                               break;
+                       }
+#endif         /* NO_BUFFERED_WRITES */
+                       if (getarg (buffer, count, "enable",
+                                   &enable, &index) >= 0) {
+                               // enable
+                               set_enable (enable, index);
+                               break;
+                       }
+                       if (getarg (buffer, count, "direct",
+                                   &direct, &index) >= 0) {
+                               // enable
+                                set_direct(direct, index);
+                               break;
+                        }
+                       if (getarg (buffer, count, "reset",
+                                   &reset, &index) >= 0) {
+                               // reset
+                               do_reset(reset, index);
+                               break;
+                       }
+                       NBD_ERROR ("illegal %ld character command\n",
+                                  count);
+                       return -EINVAL;
+               } while (0);
+               break;
+       }
+       return count;
+}
+
+void
+nbd_init_proc(struct proc_dir_entry *res) {
+        res->read_proc = nbd_read_proc;
+        res->write_proc = nbd_write_proc;
+}
+
--- linux-2.5.64/drivers/Makefile.pre-enbd      Wed Mar  5 04:29:33 2003
+++ linux-2.5.64/drivers/Makefile       Mon Mar 24 17:44:04 2003
@@ -30,6 +30,7 @@
 obj-$(CONFIG_SBUS)             += sbus/
 obj-$(CONFIG_ZORRO)            += zorro/
 obj-$(CONFIG_MAC)              += macintosh/
+obj-$(CONFIG_ENBD)             += block/enbd/
 obj-$(CONFIG_PARIDE)           += block/paride/
 obj-$(CONFIG_TC)               += tc/
 obj-$(CONFIG_USB)              += usb/
--- linux-2.5.64/include/linux/enbd.h.pre-enbd  Tue Mar 25 15:20:38 2003
+++ linux-2.5.64/include/linux/enbd.h   Tue Mar 25 14:17:37 2003
@@ -0,0 +1,517 @@
+#ifndef LINUX_ENBD_H
+#define LINUX_ENBD_H
+
+/* unsigned comments are Pavel's originals for 2.1.*
+ *   pavel@atrey.karlin.mff.cuni.cz (Pavel Machek)
+ * comments marked PTB are from
+ *   ptb@it.uc3m.es (Peter T. Breuer)
+ * comments marked AMARIN are from
+ *   amarin@it.uc3m.es (Andres Marin Lopez)
+ */
+
+#include <asm/types.h>
+
+#ifndef NBD_VERSION
+#define NBD_VERSION "2.4.30 $Date$"
+#endif /*NBD_VERSION*/
+
+  /*
+   * Third type of request apart from READ or WRITE
+   */
+  #ifndef IOCTL
+  # define IOCTL 2
+  #endif
+  /*
+   * and fourth ..
+   */
+  #ifndef MD5SUM
+  # define MD5SUM 3
+  #endif
+  /*
+   * and fifth ..
+   */
+  #ifndef SPECIAL
+  # define SPECIAL 4
+  #endif
+
+  /*
+   * We need extra bits of req->flags
+   * */
+  # define __REQ_NBD       __REQ_NR_BITS
+  # define REQ_NBD         (1 << __REQ_NBD)
+  # define __REQ_NBDSEQNO  (__REQ_NR_BITS + 1)
+  # define REQ_NBDSEQNO    (1 << __REQ_NBDSEQNO)
+  // PTB ... and all the other bits are seqno too!
+
+/* PTB - new style ioctl assignments */
+  #define NBD_SET_SOCK         _IOW(0xab, 0x00, int)
+  #define NBD_TEST_IOCTL1      _IOW(0xab, 0x01, int)
+  #define NBD_SET_SIZE         _IOW(0xab, 0x02, int)
+  #define NBD_DO_IT            _IOW(0xab, 0x03, int)
+  #define NBD_CLEAR_SOCK       _IOW(0xab, 0x04, int)
+  #define NBD_CLEAR_QUE        _IO (0xab, 0x05)
+  #define NBD_PRINT_DEBUG      _IO (0xab, 0x06)
+  #define NBD_TEST_IOCTL2      _IOR(0xab, 0x07, int)
+  #define NBD_HARD_RESET       _IO (0xab, 0x09)
+  #define NBD_DEC_USE_COUNT    _IO (0xab, 0x09)
+  #define MY_NBD_ACK           _IOW(0xab, 0x0a, char *)
+  #define MY_NBD_GET_REQ       _IOW(0xab, 0x0b, char *)
+  #define MY_NBD_REG_BUF       _IOW(0xab, 0x0c, char *)
+  #define MY_NBD_CLR_REQ       _IOW(0xab, 0x0d, int)
+  #define MY_NBD_SYNC          _IOW(0xab, 0x0e, int)
+  #define NBD_SET_SECTORS      _IOW(0xab, 0x0f, int)
+  #define MY_NBD_SET_SIG       _IOW(0xab, 0x10, int *)
+  #define NBD_RESET            _IO (0xab, 0x11)
+  #define NBD_TEST_IOCTL3      _IOWR(0xab, 0x12, int)
+  #define MY_NBD_ERR_REQ       _IOW(0xab, 0x13, int)
+  #define MY_NBD_SET_INTVL     _IOW(0xab, 0x14, int)
+  #define MY_NBD_SET_SHOW_ERRS _IOW(0xab, 0x15, int) 
+  #define NBD_SET_MD5SUM       _IOW(0xab, 0x16, int) 
+  #define MY_NBD_SET_BUFFERWR  _IOW(0xab, 0x17, int) 
+  #define MY_NBD_INVALIDATE    _IOW(0xab, 0x18, int)
+  #define MY_NBD_SET_SPID      _IOW(0xab, 0x19, int) 
+  #define MY_NBD_SET_RQ_HANDLE _IOW(0xab, 0x1a, void*) 
+  #define MY_NBD_SET_RQ_SEQNO  _IOW(0xab, 0x1b, int) 
+  #define MY_NBD_SET_RQ_DIGEST _IOWR(0xab, 0x1d, nbd_digest_t) 
+  #define NBD_TEST_IOCTL4      _IOR(0xab, 0x1e, char[256])
+  #define NBD_TEST_IOCTL5      _IOWR(0xab, 0x1f, char[256])
+  #define NBD_TEST_IOCTL6      _IO(0xab, 0x20) // special r 256B
+  #define NBD_TEST_IOCTL7      _IO(0xab, 0x21) // special rw 256B
+  #define NBD_SET_BLKSIZE      _IOW(0xab, 0x22, int)
+  #define NBD_GET_BLKSIZE      _IOR(0xab, 0x23, long)
+  #define NBD_SET_PF_MEMALLOC  _IOW(0xab, 0x24, int)
+  #define MY_NBD_SET_DIRECT    _IOW(0xab, 0x25, int) 
+  #define MY_NBD_GET_NPORT     _IOR(0xab, 0x26, int)
+
+#define MAX_NBD 16          /* PTB MAX was 128, but that's a lot */
+#define NBD_SHIFT 4         /* PTB 16 partitions/sockets/slots per device */
+                            /* PTB number of socket slots per device */
+#define NBD_MAXCONN (1<<NBD_SHIFT)
+#define NBD_SIGLEN 128      /* PTB length of sig on device */
+#define NBD_MAX_SECTORS 512 /* PTB max number of 512B sectors in a buffer */
+
+
+#if defined(MAJOR_NR) || defined(__KERNEL__)
+  /* PTB we are included from the kernel nbd.c file so put kernel stuff here */
+
+  #include <linux/config.h>
+
+  #define ENDREQ_NOCURRENT
+  #define LOCAL_END_REQUEST
+  #include <linux/blk.h>
+
+
+  /* PTB various defaults */
+  #define NBD_RAHEAD_DFLT    24 /* PTB slow medium                  */
+  #define NBD_SYNC_INTVL      0 /* PTB sync every nK reqs (default disable) */
+  #define NBD_REQ_TIMEO       5 /* PTB client inactivity chk intvl (rollback) */
+  #define NBD_SPEED_LIM  100000 /* PTB limit to 100M write reqs/s */
+  #define NBD_MERGE_REQ_DFLT  0 /* PTB until accounting fixed! */
+   /* PTB Jens Axboe says that plug should always be set in 2.4.* */
+  #define NBD_PLUG_DFLT       1 
+  #define NBD_MD5SUM_DFLT     0 
+
+/*
+ * PTB User messaging defs.
+ */
+
+  #define NBD_ID "NBD #%d[%d]: %s "
+
+  #define NBD_DEBUG(level, s...) \
+  { static int icnt; printk( KERN_DEBUG NBD_ID, __LINE__, icnt++, __FUNCTION__); printk(s);}
+  #define NBD_ERROR( s...) \
+  { static int icnt; printk( KERN_ERR   NBD_ID, __LINE__, icnt++, __FUNCTION__); printk(s);}
+  #define NBD_ALERT( s...) \
+  { static int icnt; printk( KERN_ALERT NBD_ID, __LINE__, icnt++, __FUNCTION__); printk(s);}
+  #define NBD_INFO( s...)  \
+  { static int icnt; printk( KERN_INFO  NBD_ID, __LINE__, icnt++, __FUNCTION__); printk(s);}
+
+
+
+    struct nbd_slot {
+      struct file * file;      /* PTB add - for refcnt, NULL if slot empty */
+      struct socket * sock;    /* PTB add                          */
+      int in;                  /* PTB add - tot blocks entered     */
+      int out;                 /* PTB add - tot blocks released    */
+      int err;                 /* PTB add - tot blocks errored     */
+      int req;                 /* PTB add - tot blocks pending     */
+      char * buffer;           /* PTB add - user space buffer      */
+      int  bufsiz;             /* PTB add - user space buffer size */
+      struct list_head queue;
+      unsigned long req_age;   /* PTB add - age of pending req     */
+      unsigned long cli_age;   /* PTB add - age of client          */
+      struct nbd_device *lo;   /* PTB add - parent device          */
+    #define NBD_SLOT_RUNNING   0x0001
+    #define NBD_SLOT_WAITING   0x0002
+    #define NBD_SLOT_BUFFERED  0x0004
+    #define NBD_SLOT_MD5SUM    0x8000 /* slot reply has a digest in it ..*/
+    #define NBD_SLOT_MD5_OK   0x10000 /* .. and equaled req's */
+      int flags;               /* PTB add */
+      int i;                   /* PTB add - slot number */
+      int buflen;              /* PTB add - buffer byte count */
+      int pid;                 /* PTB add - client process */
+      int refcnt;              /* PTB add - so can set_sock/clr_sock ourself */
+      int nerrs;               /* PTB add - local error count */
+      int spid;                /* PTB add - server pid */
+    };
+
+  struct nbd_md;
+  struct nbd_md {
+    int count;
+    struct semaphore access_sem;
+    int (*notify_fn)(kdev_t, int);
+    int (*notify)(struct nbd_md *,kdev_t);
+    int (*unnotify)(struct nbd_md *,kdev_t);
+    void (*dec)(struct nbd_md *);
+    void (*inc)(struct nbd_md *);
+    void (*reg)(struct nbd_md *, int(*)(kdev_t, int));
+  };
+
+  struct nbd_speed {
+    atomic_t speed;                      /* PTB add - current speed in KB/s */
+    atomic_t speedmax;                   /* PTB add - max speed */
+    atomic_t speedav;                    /* PTB add - average speed */
+    atomic_t distance;                   /* PTB add - last distance measure */
+    atomic_t jiffy;                      /* PTB add - last jiffies speed set */
+    atomic_t frstj;                      /* PTB add - first jiffies */
+    void (*update)(struct nbd_speed*, int);
+  };
+
+  struct nbd_md_list {
+    struct list_head list;
+    kdev_t dev;
+  };
+
+  struct nbd_seqno;  // forward decl
+  struct nbd_seqno {
+      unsigned int seqno;                  /* PTB add - sequence number */
+      atomic_t seqno_gen;                  /* PTB add - seqno genration */
+      void (*inc)(struct nbd_seqno *);
+      int  (*get)(struct nbd_seqno *);
+      void (*reset)(struct nbd_seqno *);
+      unsigned (*calc)(struct nbd_seqno *, unsigned);
+  };
+
+  struct nbd_device {
+      atomic_t refcnt; 
+
+    #define NBD_READ_ONLY   0x0001
+    #define NBD_WRITE_NOCHK 0x0002
+    #define NBD_INITIALISED 0x0004
+    #define NBD_SIGNED      0x0008
+
+    #define NBD_ENABLED     0x0010
+    #define NBD_SIZED       0x0020
+    #define NBD_BLKSIZED    0x0040
+
+    #define NBD_QBLOCKED    0x0100
+    #define NBD_SHOW_ERRS   0x0200
+    #define NBD_SYNC        0x0400
+    #define NBD_VALIDATED   0x0800         /* read partition table */
+
+    #define NBD_BUFFERWR    0x1000         /* buffer writes to device */
+    #define NBD_REMOTE_INVALID \
+                            0x2000         /* remote resource vanished */
+    #define NBD_DIRECT      0x4000         /* convert opens to O_DIRECT */
+    #define NBD_MD5SUM      0x8000
+
+
+      atomic_t flags;
+      int harderror;                      /* Code of hard error            */
+      int magic;                          /* FIXME: not if debugging is off  */
+      struct list_head queue;
+      rwlock_t queue_lock;                 /* PTB add - spinlock */
+      int nslot;                           /* PTB add - total slots */
+      atomic_t islot;                      /* PTB add - current slot */
+      int aslot;                           /* PTB add - total active slots*/
+      atomic_t requests_in[2];             /* PTB add - blocks put on queue */
+      atomic_t requests_out[2];            /* PTB add - blocks out from queue */
+      atomic_t requests_err;               /* PTB add - blocks erred on queue */
+      atomic_t wrequests_5so;              /* PTB add - write blocks md5 skip */
+      atomic_t wrequests_5wo;              /* PTB add - write blocks md5 wr */
+      atomic_t wrequests_5eo;              /* PTB add - write blocks md5 refus*/
+      atomic_t wrequests_5to;              /* PTB add - write blocks md5sum */
+      atomic_t wrequests_5co;              /* PTB add - write blocks md5 tot */
+      atomic_t wrequests_5no;              /* PTB add - write blocks not md5 */
+      atomic_t requests_req[2];            /* PTB add - read blocks pending */
+      atomic_t kwaiters;                   /* PTB add - kernel thrds waiting */
+      atomic_t kthreads;                   /* PTB add - kernel threads in */
+      atomic_t maxq[2];                    /* PTB add - max req queue depth */
+      atomic_t countq[2];                  /* PTB add - request queue depth */
+      atomic_t errors;                     /* PTB add - tot requests errored */
+      struct nbd_seqno seqno_out;          /* PTB add - seq number */
+      atomic_t cwaiters;                   /* PTB add - client thrds waiting */
+      atomic_t cthreads;                   /* PTB add - client threads in */
+      atomic_t req_in[2][1 + NBD_MAX_SECTORS/2];
+      wait_queue_head_t wq;                /* PTB add */
+      struct nbd_slot slots[NBD_MAXCONN];  /* PTB add - client array */
+      unsigned blksize;                    /* PTB add - device blksize in B */
+      u64 bytesize;                        /* PTB add - device size in B */
+      u64 sectors;                         /* PTB add - device size (sectors) */
+      unsigned size;                       /* PTB add - device size in blks */
+      unsigned logblksize;                 /* PTB add - log2 blksize */
+      unsigned nbd;                        /* PTB add - this array index */
+      int signature[NBD_SIGLEN/sizeof(int)];
+                                           /* PTB add - server sig */
+      struct file * file;                  /* PTB add - for ref */
+      struct inode * inode;                /* PTB add - for ref */
+      int  bufsiz;                         /* PTB add - userspace buffer size */
+      atomic_t kmax;                       /* PTB add - max kernel threads */
+      char *blockmap;                      /* PTB add - map of block states */
+      unsigned long disabled;              /* PTB add - when was it disabled */
+      int req_timeo;                       /* PTB add - inactivity timeout */
+      struct timer_list run_queue;         /* PTB add - run queue */
+      struct work_struct task_queue;       /* PTB add - task queue */
+      char devnam[4];                      /* PTB add - drive letters */
+      atomic_t maxreqblks;                 /* PTB add - maximum req size seen */
+      int max_sectors;                     /* PTB add - max req size allowed! */
+      int lives;                           /* PTB add - # times enabled */
+      // PTB speed measurement settings
+      struct nbd_speed tspeed;
+      struct nbd_speed wspeed;
+      struct nbd_speed rspeed;
+      int dummy;                           /* PTB add - unused */
+      struct request *req;                 /* PTB fake request for ioctls */
+      wait_queue_head_t req_wq;            /* PTB req done notifications */
+      struct request *rq;                  /* PTB special request ptr */
+      struct list_head altqueue;           /* PTB diverted requests */
+      rwlock_t altqueue_lock;              /* PTB add - diverted reqs lock */
+      atomic_t seqno_in;                   /* PTB add - unacked reqs */
+      struct semaphore pid_sem;            /* PTB control setting pid */
+      struct gendisk *disk;                /* PTB for partitions */
+      struct request_queue *q;             /* PTB make queue internal */
+      rwlock_t meta_lock;                  /* PTB add - spinlock meta data */
+      atomic_t merge_requests;             /* PTB local req blks limit - 1 */
+      unsigned long reenable_time;         /* PTB time to delayed reenable */
+      void (*enable)    (struct nbd_device *lo);
+      void (*reset)     (struct nbd_device *lo, int i);
+      int  (*disable)   (struct nbd_device *lo);
+      int  (*read_only) (struct nbd_device *lo);
+      void (*set_speed) (struct nbd_device *lo);
+      int  (*hard_reset)(struct nbd_device *lo);
+      int  (*soft_reset)(struct nbd_device *lo);
+      int  (*reenable_delay) (struct nbd_device *lo, int delay);
+    };
+
+#endif  /* MAJOR_NR */
+
+
+
+/* Pavel - This now IS in some kind of include file... */
+
+/* PTB 132 */ 
+#define NBD_INIT_MAGIC 0x12345678       /* AMARIN */
+#define NBD_REQUEST_MAGIC 0x25609513
+#define NBD_REPLY_MAGIC 0x67446698     
+/* Pavel - Do *not* use magics: 0x12560953 0x96744668. 
+ */
+
+#define NBD_DEV_MAGIC 0x68797548
+
+#define NBD_REQUEST_MAGIC_T  __u32
+#define NBD_REQUEST_TYPE_T   __u32
+#define NBD_REQUEST_FROM_T   __u64
+#define NBD_REQUEST_LEN_T    __u32
+#define NBD_REQUEST_FLAGS_T  __u32
+#define NBD_REQUEST_TIME_T   __u64
+#define NBD_REQUEST_ZONE_T   __u64
+#define NBD_REQUEST_SPECIAL_T  __u32
+
+#define NBD_REPLY_MAGIC_T    __u32
+#define NBD_REPLY_ERROR_T    __s32
+#define NBD_REPLY_FLAGS_T    __u32
+#define NBD_REPLY_TIME_T     __u64
+#define NBD_REPLY_ZONE_T     __u64
+
+#define NBD_REQUEST_HANDLE_T __u32
+#define NBD_REPLY_HANDLE_T   __u32
+
+  typedef __u32 nbd_digest_t[4];
+
+  #define NBD_DIGEST_T   nbd_digest_t
+
+#define NBD_REQUEST_DIGEST_T nbd_digest_t
+#define NBD_REPLY_DIGEST_T   nbd_digest_t
+
+
+#define NBD_DIGEST_BITS      128
+#define NBD_DIGEST_LENGTH    ((NBD_DIGEST_BITS)/8)
+#define NBD_REQUEST_SEQNO_T  __u32
+
+struct nbd_request {
+  NBD_REQUEST_MAGIC_T  magic;
+  NBD_REQUEST_TYPE_T   type;                   /* == READ || == WRITE  */
+  NBD_REQUEST_HANDLE_T handle;
+  NBD_REQUEST_FROM_T   from;                    /* 64 bit PTB 132 */
+  NBD_REQUEST_LEN_T    len;
+
+
+
+#define NBD_REQUEST_ERRORED    0x0800
+#define NBD_REQUEST_MD5SUM     0x8000         /* has a digest in it ..*/
+#define NBD_REQUEST_MD5_OK    0x10000         /* .. and equaled req's */
+#define NBD_REQUEST_IOCTL     0x40000         /* ioctl in len, arg in from */
+#define NBD_REQUEST_SPECIALRW 0x80000         /* 1 for w 0 for r on special */
+  NBD_REQUEST_FLAGS_T  flags;
+  NBD_REQUEST_TIME_T   time;
+  NBD_REQUEST_ZONE_T   zone;
+  NBD_REQUEST_SEQNO_T  seqno;
+  union {
+       NBD_REQUEST_DIGEST_T digest;
+  } data;
+  NBD_REQUEST_SPECIAL_T special;
+  char dummy0[0];
+  char dummy1[0] __attribute__ ((aligned (64)));
+} __attribute__ ((packed)) ;
+
+  #define NBD_REQUEST_LENGTH sizeof(struct nbd_request)
+
+struct nbd_reply {
+  NBD_REPLY_MAGIC_T    magic;
+  NBD_REPLY_ERROR_T    error;                /* 0 = ok, else error     */
+  NBD_REPLY_HANDLE_T   handle;               /* handle you got from request */
+
+
+
+#define NBD_REPLY_ERRORED      0x0800
+#define NBD_REPLY_MD5SUM       0x8000         /* has a digest in it .. */
+#define NBD_REPLY_MD5_OK      0x10000         /* .. and equaled req's  */
+#define NBD_REPLY_CLOSE       0x20000         /* close cmd from server */
+#define NBD_REPLY_IOCTL       0x40000         /* ioctl in len, arg in from */
+  NBD_REPLY_FLAGS_T    flags;
+  NBD_REPLY_TIME_T     time;
+  NBD_REPLY_ZONE_T     zone;
+  union {
+       NBD_REPLY_DIGEST_T digest;
+  } data;
+  char dummy0[0];
+  char dummy1[0] __attribute__ ((aligned (64)));
+} __attribute__ ((packed)) ;
+
+  #define NBD_REPLY_LENGTH sizeof(struct nbd_reply)
+
+  #define NBD_BUFFER_DATA_OFFSET \
+   ((NBD_REQUEST_LENGTH>NBD_REPLY_LENGTH)?NBD_REQUEST_LENGTH:NBD_REPLY_LENGTH)
+
+  #ifdef MAJOR_NR
+
+  // PTB forward declaration
+  static struct nbd_device nbd_dev[];
+
+
+  static long wait_for_completion_timeout(struct completion *x, long timeout)
+  {
+       spin_lock_irq(&x->wait.lock);
+       if (!x->done && timeout > 0) {
+               DECLARE_WAITQUEUE(wait, current);
+
+               wait.flags |= WQ_FLAG_EXCLUSIVE;
+               __add_wait_queue_tail(&x->wait, &wait);
+               do {
+                       __set_current_state(TASK_UNINTERRUPTIBLE);
+                       spin_unlock_irq(&x->wait.lock);
+                       timeout = schedule_timeout(timeout);
+                       spin_lock_irq(&x->wait.lock);
+               } while (!x->done && timeout > 0);
+               __remove_wait_queue(&x->wait, &wait);
+       }
+        if (x->done) {
+               x->done--;
+                if (timeout <= 0)
+                        timeout = 1;
+        }
+       spin_unlock_irq(&x->wait.lock);
+        return timeout;
+  }
+
+  static void end_request(struct request *req, int uptodate) {  
+
+     struct bio *bio;
+     struct nbd_device *lo = req->rq_disk->private_data;
+     static int rq_type(struct request *);
+
+     if (rq_type(req) == IOCTL) {
+            // PTB this is the devices ioctl request 
+            complete(req->waiting);
+            // PTB let the driver code return the req, etc.
+            return;
+     }
+
+     /* unlock chained buffers */
+     while ((bio = req->bio) != NULL) {
+            unsigned nsect = bio_sectors(bio);
+            blk_finished_io(nsect);
+            req->bio = bio->bi_next;
+            bio->bi_next = NULL;
+            bio_endio(bio, nsect << 9, uptodate ? 0 : -EIO);
+     }
+
+     if (req->flags & REQ_SPECIAL)
+            // don't account specials
+            return;
+
+     write_lock(&lo->altqueue_lock);
+     if (atomic_read(&lo->countq[READ])
+       + atomic_read(&lo->countq[WRITE]) == 0) {
+            if (atomic_read(&lo->flags) & NBD_QBLOCKED) {
+                    static int nbd_requeue(struct nbd_device *);
+                    nbd_requeue(lo);
+                    atomic_clear_mask(NBD_QBLOCKED, &lo->flags);
+            } 
+     } 
+     write_unlock(&lo->altqueue_lock);
+  }
+     
+ /* 
+  * PTB This takes the spinlock itself! So call it with the io spinlock
+  * not held.
+  */
+  static void end_request_lock(struct request *req, int uptodate) {  
+
+     unsigned long flags;
+     request_queue_t *q = req->q;
+
+     spin_lock_irqsave(q->queue_lock, flags);
+     end_request(req, uptodate);
+     spin_unlock_irqrestore(q->queue_lock, flags);
+  }
+
+ /*
+  * PTB Call this only with the io spinlock * held.
+  */
+  static inline void nbd_end_request(struct request *req) {
+
+    // PTB the kernel has only 2 queues, read and write, and it uses
+    // the cmd field to determine to which the req belongs. We add a
+    // seqno to it in nbd_do_req, so we reestablish it here.
+    static void rq_set_seqno(struct request *, int);
+
+    rq_set_seqno(req, 0); // PTB Zero extra seqno info
+    end_request( req, (req->errors == 0) ? 1 : 0 );
+  }
+
+ /* 
+  * PTB This takes the spinlock itself! So call it with the io spinlock
+  * not held.
+  */
+  static void nbd_end_request_lock(struct request *req) {  
+
+    // PTB the kernel has only 2 queues, read and write, and it uses
+    // the cmd field to determine to which the req belongs. We add a
+    // seqno to it in nbd_do_req, so we reestablish it here.
+    static void rq_set_seqno(struct request *, int);
+
+    rq_set_seqno(req, 0); // PTB Zero extra seqno info
+    end_request_lock( req, !req->errors );
+  }
+
+  extern int nbd_init_seqno(struct nbd_seqno *);
+  extern int nbd_init_speed(struct nbd_speed *);
+  extern int nbd_init_md(struct nbd_md *);
+  extern void nbd_init_proc(struct proc_dir_entry *res);
+
+  #endif /* MAJOR_NR */
+
+#endif /* LINUX_ENBD_H */
+
+
--- linux-2.5.64/include/linux/enbd_ioctl.h.pre-enbd    Tue Mar 25 15:20:45 2003
+++ linux-2.5.64/include/linux/enbd_ioctl.h     Mon Mar 24 22:52:26 2003
@@ -0,0 +1,56 @@
+#ifndef NBD_IOCTL_H
+#define NBD_IOCTL_H 1
+
+int nbd_ioctl_convert(int ioctl);
+int nbd_ioctl_convert_inplace(int *ioctl);
+int nbd_ioctl_revert(int ioctl);
+int nbd_ioctl_size (int cmd, char *arg);
+int nbd_ioctl_size_user (int cmd, char *arg);
+#ifdef __KERNEL__
+int nbd_ioctl_copy_to_user (int cmd, char *arg, char *buf, int size);
+int nbd_ioctl_copy_from_user (int cmd, char *buf, char *arg, int size);
+
+/*
+ * PTB object containing all the above methods, to be registered with
+ * the enbd.o module
+ */
+struct nbd_ioctl {
+#define NBD_REMOTE_IOCTL_ENABLED 0x01
+        unsigned long flags;
+        int (*convert)        (int ioctl);
+        int (*convert_inplace)(int *ioctl);
+        int (*revert)         (int ioctl);
+        int (*size)           (int cmd, char *arg);
+        int (*size_user)      (int cmd, char *arg);
+        int (*cp_to_user)     (int cmd, char *arg, char *buf, int size);
+        int (*cp_from_user)   (int cmd, char *buf, char *arg, int size);
+};
+
+struct nbd_ioctl_stub {
+        struct nbd_ioctl *    remote;
+        int (*reg)       (struct nbd_ioctl_stub *,struct nbd_ioctl *);
+        int (*unreg)     (struct nbd_ioctl_stub *,struct nbd_ioctl *);
+};
+
+extern struct nbd_ioctl_stub nbd_remote_ioctl;
+extern int nbd_init_ioctl_stub(struct nbd_ioctl_stub *);
+#endif
+
+// PTB conversion table entries
+struct ioctl_conv {
+   unsigned int old; // ioctl id, _IO or _IOR or _IOW or _IOWR
+   unsigned int new; // ioctl id
+};
+
+// PTB extended conversion table entries
+struct ioctl_special {
+    int new;
+    int (*size) (char *arg);
+    int (*size_user) (char *arg);
+    int (*ioctl_copy_from_user)(char *buf, char*arg, int size);
+    int (*ioctl_copy_to_user)(char *arg, char*buf, int size);
+};
+
+extern int nbd_init_ioctl_stub(struct nbd_ioctl_stub *);
+
+#endif /* NBD_IOCTL_H */