Index: cpukit/libblock/include/rtems/blkdev.h
===================================================================
--- cpukit/libblock/include/rtems/blkdev.h	(revision a5fb40cf68025f82a1523c33fe5f65ccbe57670e)
+++ cpukit/libblock/include/rtems/blkdev.h	(revision f031251cee129a9fbce4041510602edf8d123c06)
@@ -88,9 +88,5 @@
     /* If status != RTEMS_SUCCESSFUL, this field contains error code */
     int error;
-    /* Start block number */
-    rtems_blkdev_bnum start;
-    /* Number of blocks to be exchanged */
-    uint32_t count;
-    /* Number of buffers provided */
+    /* Number of blocks for this request. */
     uint32_t bufnum;
 
@@ -101,4 +97,8 @@
     rtems_blkdev_sg_buffer bufs[0];
 } rtems_blkdev_request;
+
+/* The start block in a request. Only valid if the driver has returned the
+ * RTEMS_BLKDEV_CAPABILITIES of RTEMS_BLKDEV_CAP_MULTISECTOR_CONT */
+#define RTEMS_BLKDEV_START_BLOCK(_r) (_r->bufs[0].block)
 
 /* Block device IOCTL request codes */
Index: cpukit/libblock/src/bdbuf.c
===================================================================
--- cpukit/libblock/src/bdbuf.c	(revision a5fb40cf68025f82a1523c33fe5f65ccbe57670e)
+++ cpukit/libblock/src/bdbuf.c	(revision f031251cee129a9fbce4041510602edf8d123c06)
@@ -1508,5 +1508,8 @@
  * already with a user when this call is made the call is blocked until the
  * buffer is returned. The highest priority waiter will obtain the buffer
- * first. 
+ * first.
+ *
+ * @note Read ahead always reads buffers in sequence. All multi-block reads
+ *       read consecutive blocks.
  *
  * @param device Device number (constructed of major and minor device number)
@@ -1556,5 +1559,4 @@
   }
 
-  req->count = 0;
   req->bufnum = 0;
 
@@ -1575,5 +1577,5 @@
   rtems_bdbuf_lock_pool (pool);
 
-  while (req->count < read_ahead_count)
+  while (req->bufnum < read_ahead_count)
   {
     /*
@@ -1586,6 +1588,6 @@
      */
     bd = rtems_bdbuf_get_buffer (dd->phys_dev, pool,
-                                 block + req->count,
-                                 req->count == 0 ? FALSE : TRUE);
+                                 block + req->bufnum,
+                                 req->bufnum == 0 ? FALSE : TRUE);
 
     /*
@@ -1614,9 +1616,8 @@
      *       node that can be used.
      */
-    req->bufs[req->count].user   = bd;
-    req->bufs[req->count].block  = bd->block;
-    req->bufs[req->count].length = dd->block_size;
-    req->bufs[req->count].buffer = bd->buffer;
-    req->count++;
+    req->bufs[req->bufnum].user   = bd;
+    req->bufs[req->bufnum].block  = bd->block;
+    req->bufs[req->bufnum].length = dd->block_size;
+    req->bufs[req->bufnum].buffer = bd->buffer;
     req->bufnum++;
   }
@@ -1626,5 +1627,5 @@
    * the block in the cache so return it.
    */
-  if (req->count)
+  if (req->bufnum)
   {
     /*
@@ -1650,5 +1651,4 @@
     req->status = RTEMS_RESOURCE_IN_USE;
     req->error = 0;
-    req->start = dd->start;
   
     result = dd->ioctl (dd->phys_dev->dev, RTEMS_BLKIO_REQUEST, req);
@@ -1677,5 +1677,5 @@
     rtems_bdbuf_lock_pool (pool);
 
-    for (b = 1; b < req->count; b++)
+    for (b = 1; b < req->bufnum; b++)
     {
       bd = req->bufs[b].user;
@@ -2049,8 +2049,36 @@
         {
           rtems_chain_node* next_node = node->next;
+          rtems_chain_node* tnode = rtems_chain_tail (transfer);
+    
+          /*
+           * The blocks on the transfer list are sorted in block order. This
+           * means multi-block transfers for drivers that require consecutive
+           * blocks perform better with sorted blocks and for real disks it may
+           * help lower head movement.
+           */
+
+          bd->state = RTEMS_BDBUF_STATE_TRANSFER;
+
           rtems_chain_extract (node);
-          rtems_chain_append (transfer, node);
+
+          tnode = tnode->previous;
+          
+          while (node && !rtems_chain_is_head (transfer, tnode))
+          {
+            rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
+
+            if (bd->block > tbd->block)
+            {
+              rtems_chain_insert (tnode, node);
+              node = NULL;
+            }
+            else
+              tnode = tnode->previous;
+          }
+
+          if (node)
+            rtems_chain_prepend (transfer, node);
+          
           node = next_node;
-          bd->state = RTEMS_BDBUF_STATE_TRANSFER;
         }
         else
@@ -2162,7 +2190,5 @@
 
       write_req->status = RTEMS_RESOURCE_IN_USE;
-      write_req->start = dd->start;
       write_req->error = 0;
-      write_req->count = 0;
       write_req->bufnum = 0;
 
@@ -2182,5 +2208,5 @@
         
         if ((dd->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
-            write_req->count &&
+            write_req->bufnum &&
             (bd->block != (last_block + 1)))
         {
@@ -2190,9 +2216,8 @@
         else
         {
-          write_req->bufs[write_req->count].user   = bd;
-          write_req->bufs[write_req->count].block  = bd->block;
-          write_req->bufs[write_req->count].length = dd->block_size;
-          write_req->bufs[write_req->count].buffer = bd->buffer;
-          write_req->count++;
+          write_req->bufs[write_req->bufnum].user   = bd;
+          write_req->bufs[write_req->bufnum].block  = bd->block;
+          write_req->bufs[write_req->bufnum].length = dd->block_size;
+          write_req->bufs[write_req->bufnum].buffer = bd->buffer;
           write_req->bufnum++;
           last_block = bd->block;
@@ -2205,5 +2230,5 @@
 
         if (rtems_chain_is_empty (&transfer) ||
-            (write_req->count >= rtems_bdbuf_configuration.max_write_blocks))
+            (write_req->bufnum >= rtems_bdbuf_configuration.max_write_blocks))
           write = TRUE;
 
@@ -2224,5 +2249,5 @@
             rtems_bdbuf_lock_pool (pool);
               
-            for (b = 0; b < write_req->count; b++)
+            for (b = 0; b < write_req->bufnum; b++)
             {
               bd = write_req->bufs[b].user;
@@ -2253,5 +2278,5 @@
             rtems_bdbuf_lock_pool (pool);
 
-            for (b = 0; b < write_req->count; b++)
+            for (b = 0; b < write_req->bufnum; b++)
             {
               bd = write_req->bufs[b].user;
@@ -2275,5 +2300,4 @@
           write_req->status = RTEMS_RESOURCE_IN_USE;
           write_req->error = 0;
-          write_req->count = 0;
           write_req->bufnum = 0;
         }
Index: cpukit/libblock/src/blkdev.c
===================================================================
--- cpukit/libblock/src/blkdev.c	(revision a5fb40cf68025f82a1523c33fe5f65ccbe57670e)
+++ cpukit/libblock/src/blkdev.c	(revision f031251cee129a9fbce4041510602edf8d123c06)
@@ -233,5 +233,4 @@
         {
             rtems_blkdev_request *req = args->buffer;
-            req->start += dd->start;
             args->ioctl_return = dd->ioctl(dd->phys_dev->dev, args->command,
                                            req);
Index: cpukit/libblock/src/nvdisk.c
===================================================================
--- cpukit/libblock/src/nvdisk.c	(revision a5fb40cf68025f82a1523c33fe5f65ccbe57670e)
+++ cpukit/libblock/src/nvdisk.c	(revision f031251cee129a9fbce4041510602edf8d123c06)
@@ -589,5 +589,5 @@
 #endif
 
-  remains = req->count * nvd->block_size;
+  remains = req->bufnum * nvd->block_size;
   
   for (b = 0; b < req->bufnum; b++, sg++)
Index: cpukit/libblock/src/ramdisk.c
===================================================================
--- cpukit/libblock/src/ramdisk.c	(revision a5fb40cf68025f82a1523c33fe5f65ccbe57670e)
+++ cpukit/libblock/src/ramdisk.c	(revision f031251cee129a9fbce4041510602edf8d123c06)
@@ -100,5 +100,5 @@
 #endif
 
-    remains = rd->block_size * req->count;
+    remains = rd->block_size * req->bufnum;
     sg = req->bufs;
     for (i = 0; (remains > 0) && (i < req->bufnum); i++, sg++)
@@ -138,7 +138,7 @@
     rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d remains=%d",
                           req->bufs[0].block, req->bufnum,
-                          rd->block_size * req->count);
-#endif
-    remains = rd->block_size * req->count;
+                          rd->block_size * req->bufnum);
+#endif
+    remains = rd->block_size * req->bufnum;
     sg = req->bufs;
     for (i = 0; (remains > 0) && (i < req->bufnum); i++, sg++)
