13 files changed, 12 insertions, 277 deletions

diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index e24835b38b54..d92d5040a9fe 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -13,9 +13,9 @@
 #include <linux/kernel.h>
 
 #include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
-#include <scsi/scsi_request.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dbg.h>
 
@@ -1261,16 +1261,6 @@ void scsi_print_sense(const char *devclass, struct scsi_cmnd *cmd)
 }
 EXPORT_SYMBOL(scsi_print_sense);
 
-void scsi_print_req_sense(const char *devclass, struct scsi_request *sreq)
-{
-        const char *name = devclass;
-
-        if (sreq->sr_request->rq_disk)
-                name = sreq->sr_request->rq_disk->disk_name;
-        __scsi_print_sense(name, sreq->sr_sense_buffer, SCSI_SENSE_BUFFERSIZE);
-}
-EXPORT_SYMBOL(scsi_print_req_sense);
-
 void scsi_print_command(struct scsi_cmnd *cmd)
 {
         /* Assume appended output (i.e. not at start of line) */
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index fc4d9f61cf3d..76071a158306 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -716,8 +716,8 @@ static void gdth_scsi_done(struct scsi_cmnd *scp)
 {
     TRACE2(("gdth_scsi_done()\n"));
 
-    if (scp->sc_request)
-        complete((struct completion *)scp->sc_request);
+    if (scp->request)
+        complete((struct completion *)scp->request);
 }
 
 int __gdth_execute(struct scsi_device *sdev, gdth_cmd_str *gdtcmd, char *cmnd,
@@ -732,8 +732,8 @@ int __gdth_execute(struct scsi_device *sdev, gdth_cmd_str *gdtcmd, char *cmnd,
         return -ENOMEM;
     memset(scp, 0, sizeof(*scp));
     scp->device = sdev;
-    /* use sc_request field to save the ptr. to completion struct. */
-    scp->sc_request = (struct scsi_request *)&wait;
+    /* use request field to save the ptr. to completion struct. */
+    scp->request = (struct request *)&wait;
     scp->timeout_per_command = timeout*HZ;
     scp->request_buffer = gdtcmd;
     scp->cmd_len = 12;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 8b80e59c8c52..96b65b307dd0 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -79,7 +79,6 @@
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_cmnd.h>
-#include <scsi/scsi_request.h>
 #include "ipr.h"
 
 /*
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 994015726ec8..f1e129b7c972 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -38,9 +38,9 @@
 #include <linux/spinlock.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
+#include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_device.h>
-#include <scsi/scsi_request.h>
 #include <scsi/scsi_transport.h>
 #include <linux/libata.h>
 #include <linux/hdreg.h>
diff --git a/drivers/scsi/qlogicpti.c b/drivers/scsi/qlogicpti.c
index 00f4b846360e..417a121fcd42 100644
--- a/drivers/scsi/qlogicpti.c
+++ b/drivers/scsi/qlogicpti.c
@@ -43,7 +43,6 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_eh.h>
-#include <scsi/scsi_request.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_host.h>
 
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 73994e2ac2cb..3e90ba797df2 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -63,7 +63,6 @@
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
-#include <scsi/scsi_request.h>
 
 #include "scsi_priv.h"
 #include "scsi_logging.h"
@@ -116,79 +115,6 @@ const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE] = {
 };
 EXPORT_SYMBOL(scsi_device_types);
 
-/*
- * Function:    scsi_allocate_request
- *
- * Purpose:     Allocate a request descriptor.
- *
- * Arguments:   device          - device for which we want a request
- *              gfp_mask        - allocation flags passed to kmalloc
- *
- * Lock status: No locks assumed to be held.  This function is SMP-safe.
- *
- * Returns:     Pointer to request block.
- */
-struct scsi_request *scsi_allocate_request(struct scsi_device *sdev,
-                                           gfp_t gfp_mask)
-{
-        const int offset = ALIGN(sizeof(struct scsi_request), 4);
-        const int size = offset + sizeof(struct request);
-        struct scsi_request *sreq;
-  
-        sreq = kzalloc(size, gfp_mask);
-        if (likely(sreq != NULL)) {
-                sreq->sr_request = (struct request *)(((char *)sreq) + offset);
-                sreq->sr_device = sdev;
-                sreq->sr_host = sdev->host;
-                sreq->sr_magic = SCSI_REQ_MAGIC;
-                sreq->sr_data_direction = DMA_BIDIRECTIONAL;
-        }
-
-        return sreq;
-}
-EXPORT_SYMBOL(scsi_allocate_request);
-
-void __scsi_release_request(struct scsi_request *sreq)
-{
-        struct request *req = sreq->sr_request;
-
-        /* unlikely because the tag was usually ended earlier by the
-         * mid-layer. However, for layering reasons ULD's don't end
-         * the tag of commands they generate. */
-        if (unlikely(blk_rq_tagged(req))) {
-                unsigned long flags;
-                struct request_queue *q = req->q;
-
-                spin_lock_irqsave(q->queue_lock, flags);
-                blk_queue_end_tag(q, req);
-                spin_unlock_irqrestore(q->queue_lock, flags);
-        }
-
-
-        if (likely(sreq->sr_command != NULL)) {
-                struct scsi_cmnd *cmd = sreq->sr_command;
-
-                sreq->sr_command = NULL;
-                scsi_next_command(cmd);
-        }
-}
-
-/*
- * Function:    scsi_release_request
- *
- * Purpose:     Release a request descriptor.
- *
- * Arguments:   sreq    - request to release
- *
- * Lock status: No locks assumed to be held.  This function is SMP-safe.
- */
-void scsi_release_request(struct scsi_request *sreq)
-{
-        __scsi_release_request(sreq);
-        kfree(sreq);
-}
-EXPORT_SYMBOL(scsi_release_request);
-
 struct scsi_host_cmd_pool {
         kmem_cache_t    *slab;
         unsigned int    users;
@@ -646,73 +572,6 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
         return rtn;
 }
 
-/*
- * Function:    scsi_init_cmd_from_req
- *
- * Purpose:     Queue a SCSI command
- * Purpose:     Initialize a struct scsi_cmnd from a struct scsi_request
- *
- * Arguments:   cmd       - command descriptor.
- *              sreq      - Request from the queue.
- *
- * Lock status: None needed.
- *
- * Returns:     Nothing.
- *
- * Notes:       Mainly transfer data from the request structure to the
- *              command structure.  The request structure is allocated
- *              using the normal memory allocator, and requests can pile
- *              up to more or less any depth.  The command structure represents
- *              a consumable resource, as these are allocated into a pool
- *              when the SCSI subsystem initializes.  The preallocation is
- *              required so that in low-memory situations a disk I/O request
- *              won't cause the memory manager to try and write out a page.
- *              The request structure is generally used by ioctls and character
- *              devices.
- */
-void scsi_init_cmd_from_req(struct scsi_cmnd *cmd, struct scsi_request *sreq)
-{
-        sreq->sr_command = cmd;
-
-        cmd->cmd_len = sreq->sr_cmd_len;
-        cmd->use_sg = sreq->sr_use_sg;
-
-        cmd->request = sreq->sr_request;
-        memcpy(cmd->data_cmnd, sreq->sr_cmnd, sizeof(cmd->data_cmnd));
-        cmd->serial_number = 0;
-        cmd->bufflen = sreq->sr_bufflen;
-        cmd->buffer = sreq->sr_buffer;
-        cmd->retries = 0;
-        cmd->allowed = sreq->sr_allowed;
-        cmd->done = sreq->sr_done;
-        cmd->timeout_per_command = sreq->sr_timeout_per_command;
-        cmd->sc_data_direction = sreq->sr_data_direction;
-        cmd->sglist_len = sreq->sr_sglist_len;
-        cmd->underflow = sreq->sr_underflow;
-        cmd->sc_request = sreq;
-        memcpy(cmd->cmnd, sreq->sr_cmnd, sizeof(sreq->sr_cmnd));
-
-        /*
-         * Zero the sense buffer.  Some host adapters automatically request
-         * sense on error.  0 is not a valid sense code.
-         */
-        memset(cmd->sense_buffer, 0, sizeof(sreq->sr_sense_buffer));
-        cmd->request_buffer = sreq->sr_buffer;
-        cmd->request_bufflen = sreq->sr_bufflen;
-        cmd->old_use_sg = cmd->use_sg;
-        if (cmd->cmd_len == 0)
-                cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
-        cmd->old_cmd_len = cmd->cmd_len;
-        cmd->sc_old_data_direction = cmd->sc_data_direction;
-        cmd->old_underflow = cmd->underflow;
-
-        /*
-         * Start the timer ticking.
-         */
-        cmd->result = 0;
-
-        SCSI_LOG_MLQUEUE(3, printk("Leaving scsi_init_cmd_from_req()\n"));
-}
 
 /*
  * Per-CPU I/O completion queue.
@@ -809,7 +668,6 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
 {
         struct scsi_device *sdev = cmd->device;
         struct Scsi_Host *shost = sdev->host;
-        struct scsi_request *sreq;
 
         scsi_device_unbusy(sdev);
 
@@ -839,21 +697,6 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
          * We can get here with use_sg=0, causing a panic in the upper level
          */
         cmd->use_sg = cmd->old_use_sg;
-
-        /*
-         * If there is an associated request structure, copy the data over
-         * before we call the completion function.
-         */
-        sreq = cmd->sc_request;
-        if (sreq) {
-               sreq->sr_result = sreq->sr_command->result;
-               if (sreq->sr_result) {
-                       memcpy(sreq->sr_sense_buffer,
-                              sreq->sr_command->sense_buffer,
-                              sizeof(sreq->sr_sense_buffer));
-               }
-        }
-
         cmd->done(cmd);
 }
 EXPORT_SYMBOL(scsi_finish_command);
diff --git a/drivers/scsi/scsi.h b/drivers/scsi/scsi.h
index 5ee5d80a9931..f51e466893e7 100644
--- a/drivers/scsi/scsi.h
+++ b/drivers/scsi/scsi.h
@@ -25,7 +25,6 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_eh.h>
-#include <scsi/scsi_request.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi.h>
 
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 1c75646f9689..471a43102923 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -26,13 +26,13 @@
 #include <linux/delay.h>
 
 #include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_ioctl.h>
-#include <scsi/scsi_request.h>
 
 #include "scsi_priv.h"
 #include "scsi_logging.h"
@@ -1671,8 +1671,6 @@ scsi_reset_provider(struct scsi_device *dev, int flag)
         scmd->cmd_len                   = 0;
 
         scmd->sc_data_direction         = DMA_BIDIRECTIONAL;
-        scmd->sc_request                = NULL;
-        scmd->sc_magic                  = SCSI_CMND_MAGIC;
 
         init_timer(&scmd->eh_timeout);
 
@@ -1769,14 +1767,6 @@ int scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
 }
 EXPORT_SYMBOL(scsi_normalize_sense);
 
-int scsi_request_normalize_sense(struct scsi_request *sreq,
-                                 struct scsi_sense_hdr *sshdr)
-{
-        return scsi_normalize_sense(sreq->sr_sense_buffer,
-                        sizeof(sreq->sr_sense_buffer), sshdr);
-}
-EXPORT_SYMBOL(scsi_request_normalize_sense);
-
 int scsi_command_normalize_sense(struct scsi_cmnd *cmd,
                                  struct scsi_sense_hdr *sshdr)
 {
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index a89aff61d3d8..a89c4115cfba 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -15,11 +15,11 @@
 #include <asm/uaccess.h>
 
 #include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_ioctl.h>
-#include <scsi/scsi_request.h>
 #include <scsi/sg.h>
 #include <scsi/scsi_dbg.h>
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index bdce9d1f5b71..3302d8068c41 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -19,12 +19,12 @@
 #include <linux/hardirq.h>
 
 #include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_host.h>
-#include <scsi/scsi_request.h>
 
 #include "scsi_priv.h"
 #include "scsi_logging.h"
@@ -83,7 +83,7 @@ static void scsi_unprep_request(struct request *req)
         struct scsi_cmnd *cmd = req->special;
 
         req->flags &= ~REQ_DONTPREP;
-        req->special = (req->flags & REQ_SPECIAL) ? cmd->sc_request : NULL;
+        req->special = NULL;
 
         scsi_put_command(cmd);
 }
@@ -161,72 +161,6 @@ int scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
         return 0;
 }
 
-/*
- * Function:    scsi_do_req
- *
- * Purpose:     Queue a SCSI request
- *
- * Arguments:   sreq      - command descriptor.
- *              cmnd      - actual SCSI command to be performed.
- *              buffer    - data buffer.
- *              bufflen   - size of data buffer.
- *              done      - completion function to be run.
- *              timeout   - how long to let it run before timeout.
- *              retries   - number of retries we allow.
- *
- * Lock status: No locks held upon entry.
- *
- * Returns:     Nothing.
- *
- * Notes:       This function is only used for queueing requests for things
- *              like ioctls and character device requests - this is because
- *              we essentially just inject a request into the queue for the
- *              device.
- *
- *              In order to support the scsi_device_quiesce function, we
- *              now inject requests on the *head* of the device queue
- *              rather than the tail.
- */
-void scsi_do_req(struct scsi_request *sreq, const void *cmnd,
-                 void *buffer, unsigned bufflen,
-                 void (*done)(struct scsi_cmnd *),
-                 int timeout, int retries)
-{
-        /*
-         * If the upper level driver is reusing these things, then
-         * we should release the low-level block now.  Another one will
-         * be allocated later when this request is getting queued.
-         */
-        __scsi_release_request(sreq);
-
-        /*
-         * Our own function scsi_done (which marks the host as not busy,
-         * disables the timeout counter, etc) will be called by us or by the
-         * scsi_hosts[host].queuecommand() function needs to also call
-         * the completion function for the high level driver.
-         */
-        memcpy(sreq->sr_cmnd, cmnd, sizeof(sreq->sr_cmnd));
-        sreq->sr_bufflen = bufflen;
-        sreq->sr_buffer = buffer;
-        sreq->sr_allowed = retries;
-        sreq->sr_done = done;
-        sreq->sr_timeout_per_command = timeout;
-
-        if (sreq->sr_cmd_len == 0)
-                sreq->sr_cmd_len = COMMAND_SIZE(sreq->sr_cmnd[0]);
-
-        /*
-         * head injection *required* here otherwise quiesce won't work
-         *
-         * Because users of this function are apt to reuse requests with no
-         * modification, we have to sanitise the request flags here
-         */
-        sreq->sr_request->flags &= ~REQ_DONTPREP;
-        blk_insert_request(sreq->sr_device->request_queue, sreq->sr_request,
-                           1, sreq);
-}
-EXPORT_SYMBOL(scsi_do_req);
-
 /**
  * scsi_execute - insert request and wait for the result
  * @sdev:       scsi device
@@ -1300,15 +1234,7 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
          * at request->cmd, as this tells us the real story.
          */
         if (req->flags & REQ_SPECIAL && req->special) {
-                struct scsi_request *sreq = req->special;
-
-                if (sreq->sr_magic == SCSI_REQ_MAGIC) {
-                        cmd = scsi_get_command(sreq->sr_device, GFP_ATOMIC);
-                        if (unlikely(!cmd))
-                                goto defer;
-                        scsi_init_cmd_from_req(cmd, sreq);
-                } else
-                        cmd = req->special;
+                cmd = req->special;
         } else if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) {
 
                 if(unlikely(specials_only) && !(req->flags & REQ_SPECIAL)) {
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 27c48274e8cb..a1727a0e1bdd 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -8,17 +8,10 @@ struct request_queue;
 struct scsi_cmnd;
 struct scsi_device;
 struct scsi_host_template;
-struct scsi_request;
 struct Scsi_Host;
 
 
 /*
- * Magic values for certain scsi structs. Shouldn't ever be used.
- */
-#define SCSI_CMND_MAGIC         0xE25C23A5
-#define SCSI_REQ_MAGIC          0x75F6D354
-
-/*
  * Scsi Error Handler Flags
  */
 #define SCSI_EH_CANCEL_CMD      0x0001  /* Cancel this cmd */
@@ -34,9 +27,6 @@ extern void scsi_exit_hosts(void);
 extern int scsi_dispatch_cmd(struct scsi_cmnd *cmd);
 extern int scsi_setup_command_freelist(struct Scsi_Host *shost);
 extern void scsi_destroy_command_freelist(struct Scsi_Host *shost);
-extern void scsi_init_cmd_from_req(struct scsi_cmnd *cmd,
-                struct scsi_request *sreq);
-extern void __scsi_release_request(struct scsi_request *sreq);
 extern void __scsi_done(struct scsi_cmnd *cmd);
 extern int scsi_retry_command(struct scsi_cmnd *cmd);
 #ifdef CONFIG_SCSI_LOGGING
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index fd97d07577ad..0f7e6f94d66b 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -33,11 +33,11 @@
 #include <asm/semaphore.h>
 
 #include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_devinfo.h>
 #include <scsi/scsi_host.h>
-#include <scsi/scsi_request.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_eh.h>
 
diff --git a/drivers/scsi/scsi_typedefs.h b/drivers/scsi/scsi_typedefs.h
index 29f038b42f60..2ed4c5cb7088 100644
--- a/drivers/scsi/scsi_typedefs.h
+++ b/drivers/scsi/scsi_typedefs.h
@@ -1,3 +1,2 @@
 
 typedef struct scsi_cmnd Scsi_Cmnd;
-typedef struct scsi_request Scsi_Request;