1 files changed, 176 insertions, 112 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 65a725cd3422..370dfe1c422e 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -45,6 +45,10 @@
 #include <linux/blkdev.h>
 #include <linux/genhd.h>
 #include <linux/completion.h>
+#include <scsi/scsi.h>
+#include <scsi/sg.h>
+#include <scsi/scsi_ioctl.h>
+#include <linux/cdrom.h>
 
 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
 #define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
@@ -1152,6 +1156,30 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         kfree(ioc);
                         return status;
                 }
+
+        /* scsi_cmd_ioctl handles these, below, though some are not */
+        /* very meaningful for cciss.  SG_IO is the main one people want. */
+
+        case SG_GET_VERSION_NUM:
+        case SG_SET_TIMEOUT:
+        case SG_GET_TIMEOUT:
+        case SG_GET_RESERVED_SIZE:
+        case SG_SET_RESERVED_SIZE:
+        case SG_EMULATED_HOST:
+        case SG_IO:
+        case SCSI_IOCTL_SEND_COMMAND:
+                return scsi_cmd_ioctl(filep, disk, cmd, argp);
+
+        /* scsi_cmd_ioctl would normally handle these, below, but */
+        /* they aren't a good fit for cciss, as CD-ROMs are */
+        /* not supported, and we don't have any bus/target/lun */
+        /* which we present to the kernel. */
+
+        case CDROM_SEND_PACKET:
+        case CDROMCLOSETRAY:
+        case CDROMEJECT:
+        case SCSI_IOCTL_GET_IDLUN:
+        case SCSI_IOCTL_GET_BUS_NUMBER:
         default:
                 return -ENOTTY;
         }
@@ -1234,7 +1262,7 @@ static void cciss_softirq_done(struct request *rq)
                 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
         }
 
-        complete_buffers(rq->bio, rq->errors);
+        complete_buffers(rq->bio, (rq->errors == 0));
 
         if (blk_fs_request(rq)) {
                 const int rw = rq_data_dir(rq);
@@ -1248,7 +1276,7 @@ static void cciss_softirq_done(struct request *rq)
 
         add_disk_randomness(rq->rq_disk);
         spin_lock_irqsave(&h->lock, flags);
-        end_that_request_last(rq, rq->errors);
+        end_that_request_last(rq, (rq->errors == 0));
         cmd_free(h, cmd, 1);
         cciss_check_queues(h);
         spin_unlock_irqrestore(&h->lock, flags);
@@ -2336,6 +2364,44 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
         start_io(h);
 }
 
+static inline int evaluate_target_status(CommandList_struct *cmd)
+{
+        unsigned char sense_key;
+        int error_count = 1;
+
+        if (cmd->err_info->ScsiStatus != 0x02) { /* not check condition? */
+                if (!blk_pc_request(cmd->rq))
+                        printk(KERN_WARNING "cciss: cmd %p "
+                               "has SCSI Status 0x%x\n",
+                               cmd, cmd->err_info->ScsiStatus);
+                return error_count;
+        }
+
+        /* check the sense key */
+        sense_key = 0xf & cmd->err_info->SenseInfo[2];
+        /* no status or recovered error */
+        if ((sense_key == 0x0) || (sense_key == 0x1))
+                error_count = 0;
+
+        if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
+                if (error_count != 0)
+                        printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
+                               " sense key = 0x%x\n", cmd, sense_key);
+                return error_count;
+        }
+
+        /* SG_IO or similar, copy sense data back */
+        if (cmd->rq->sense) {
+                if (cmd->rq->sense_len > cmd->err_info->SenseLen)
+                        cmd->rq->sense_len = cmd->err_info->SenseLen;
+                memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
+                        cmd->rq->sense_len);
+        } else
+                cmd->rq->sense_len = 0;
+
+        return error_count;
+}
+
 /* checks the status of the job and calls complete buffers to mark all
  * buffers for the completed job. Note that this function does not need
  * to hold the hba/queue lock.
@@ -2343,109 +2409,99 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                                     int timeout)
 {
-        int status = 1;
         int retry_cmd = 0;
+        struct request *rq = cmd->rq;
+
+        rq->errors = 0;
 
         if (timeout)
-                status = 0;
+                rq->errors = 1;
 
-        if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
-                switch (cmd->err_info->CommandStatus) {
-                        unsigned char sense_key;
-                case CMD_TARGET_STATUS:
-                        status = 0;
+        if (cmd->err_info->CommandStatus == 0)  /* no error has occurred */
+                goto after_error_processing;
 
-                        if (cmd->err_info->ScsiStatus == 0x02) {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has CHECK CONDITION "
-                                       " byte 2 = 0x%x\n", cmd,
-                                       cmd->err_info->SenseInfo[2]
-                                    );
-                                /* check the sense key */
-                                sense_key = 0xf & cmd->err_info->SenseInfo[2];
-                                /* no status or recovered error */
-                                if ((sense_key == 0x0) || (sense_key == 0x1)) {
-                                        status = 1;
-                                }
-                        } else {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has SCSI Status 0x%x\n",
-                                       cmd, cmd->err_info->ScsiStatus);
-                        }
-                        break;
-                case CMD_DATA_UNDERRUN:
+        switch (cmd->err_info->CommandStatus) {
+        case CMD_TARGET_STATUS:
+                rq->errors = evaluate_target_status(cmd);
+                break;
+        case CMD_DATA_UNDERRUN:
+                if (blk_fs_request(cmd->rq)) {
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data underrun "
                                "reported\n", cmd);
-                        break;
-                case CMD_DATA_OVERRUN:
+                        cmd->rq->data_len = cmd->err_info->ResidualCnt;
+                }
+                break;
+        case CMD_DATA_OVERRUN:
+                if (blk_fs_request(cmd->rq))
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data overrun "
                                "reported\n", cmd);
-                        break;
-                case CMD_INVALID:
-                        printk(KERN_WARNING "cciss: cmd %p is "
-                               "reported invalid\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_PROTOCOL_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p has "
-                               "protocol error \n", cmd);
-                        status = 0;
-                        break;
-                case CMD_HARDWARE_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               " hardware error\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_CONNECTION_LOST:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               "connection lost\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_ABORTED:
-                        printk(KERN_WARNING "cciss: cmd %p was "
-                               "aborted\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_ABORT_FAILED:
-                        printk(KERN_WARNING "cciss: cmd %p reports "
-                               "abort failed\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_UNSOLICITED_ABORT:
-                        printk(KERN_WARNING "cciss%d: unsolicited "
-                               "abort %p\n", h->ctlr, cmd);
-                        if (cmd->retry_count < MAX_CMD_RETRIES) {
-                                retry_cmd = 1;
-                                printk(KERN_WARNING
-                                       "cciss%d: retrying %p\n", h->ctlr, cmd);
-                                cmd->retry_count++;
-                        } else
-                                printk(KERN_WARNING
-                                       "cciss%d: %p retried too "
-                                       "many times\n", h->ctlr, cmd);
-                        status = 0;
-                        break;
-                case CMD_TIMEOUT:
-                        printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
-                        status = 0;
-                        break;
-                default:
-                        printk(KERN_WARNING "cciss: cmd %p returned "
-                               "unknown status %x\n", cmd,
-                               cmd->err_info->CommandStatus);
-                        status = 0;
-                }
+                break;
+        case CMD_INVALID:
+                printk(KERN_WARNING "cciss: cmd %p is "
+                       "reported invalid\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_PROTOCOL_ERR:
+                printk(KERN_WARNING "cciss: cmd %p has "
+                       "protocol error \n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_HARDWARE_ERR:
+                printk(KERN_WARNING "cciss: cmd %p had "
+                       " hardware error\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_CONNECTION_LOST:
+                printk(KERN_WARNING "cciss: cmd %p had "
+                       "connection lost\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_ABORTED:
+                printk(KERN_WARNING "cciss: cmd %p was "
+                       "aborted\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_ABORT_FAILED:
+                printk(KERN_WARNING "cciss: cmd %p reports "
+                       "abort failed\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                printk(KERN_WARNING "cciss%d: unsolicited "
+                       "abort %p\n", h->ctlr, cmd);
+                if (cmd->retry_count < MAX_CMD_RETRIES) {
+                        retry_cmd = 1;
+                        printk(KERN_WARNING
+                               "cciss%d: retrying %p\n", h->ctlr, cmd);
+                        cmd->retry_count++;
+                } else
+                        printk(KERN_WARNING
+                               "cciss%d: %p retried too "
+                               "many times\n", h->ctlr, cmd);
+                rq->errors = 1;
+                break;
+        case CMD_TIMEOUT:
+                printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
+                rq->errors = 1;
+                break;
+        default:
+                printk(KERN_WARNING "cciss: cmd %p returned "
+                       "unknown status %x\n", cmd,
+                       cmd->err_info->CommandStatus);
+                rq->errors = 1;
         }
+
+after_error_processing:
+
         /* We need to return this command */
         if (retry_cmd) {
                 resend_cciss_cmd(h, cmd);
                 return;
         }
-
+        cmd->rq->data_len = 0;
         cmd->rq->completion_data = cmd;
-        cmd->rq->errors = status;
         blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
         blk_complete_request(cmd->rq);
 }
@@ -2539,32 +2595,40 @@ static void do_cciss_request(request_queue_t *q)
 #endif                          /* CCISS_DEBUG */
 
         c->Header.SGList = c->Header.SGTotal = seg;
-        if(h->cciss_read == CCISS_READ_10) {
-                c->Request.CDB[1] = 0;
-                c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
-                c->Request.CDB[3] = (start_blk >> 16) & 0xff;
-                c->Request.CDB[4] = (start_blk >> 8) & 0xff;
-                c->Request.CDB[5] = start_blk & 0xff;
-                c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
-                c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
-                c->Request.CDB[8] = creq->nr_sectors & 0xff;
-                c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+        if (likely(blk_fs_request(creq))) {
+                if(h->cciss_read == CCISS_READ_10) {
+                        c->Request.CDB[1] = 0;
+                        c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
+                        c->Request.CDB[3] = (start_blk >> 16) & 0xff;
+                        c->Request.CDB[4] = (start_blk >> 8) & 0xff;
+                        c->Request.CDB[5] = start_blk & 0xff;
+                        c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
+                        c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
+                        c->Request.CDB[8] = creq->nr_sectors & 0xff;
+                        c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+                } else {
+                        c->Request.CDBLen = 16;
+                        c->Request.CDB[1]= 0;
+                        c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
+                        c->Request.CDB[3]= (start_blk >> 48) & 0xff;
+                        c->Request.CDB[4]= (start_blk >> 40) & 0xff;
+                        c->Request.CDB[5]= (start_blk >> 32) & 0xff;
+                        c->Request.CDB[6]= (start_blk >> 24) & 0xff;
+                        c->Request.CDB[7]= (start_blk >> 16) & 0xff;
+                        c->Request.CDB[8]= (start_blk >>  8) & 0xff;
+                        c->Request.CDB[9]= start_blk & 0xff;
+                        c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
+                        c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
+                        c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
+                        c->Request.CDB[13]= creq->nr_sectors & 0xff;
+                        c->Request.CDB[14] = c->Request.CDB[15] = 0;
+                }
+        } else if (blk_pc_request(creq)) {
+                c->Request.CDBLen = creq->cmd_len;
+                memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
         } else {
-                c->Request.CDBLen = 16;
-                c->Request.CDB[1]= 0;
-                c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
-                c->Request.CDB[3]= (start_blk >> 48) & 0xff;
-                c->Request.CDB[4]= (start_blk >> 40) & 0xff;
-                c->Request.CDB[5]= (start_blk >> 32) & 0xff;
-                c->Request.CDB[6]= (start_blk >> 24) & 0xff;
-                c->Request.CDB[7]= (start_blk >> 16) & 0xff;
-                c->Request.CDB[8]= (start_blk >>  8) & 0xff;
-                c->Request.CDB[9]= start_blk & 0xff;
-                c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
-                c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
-                c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
-                c->Request.CDB[13]= creq->nr_sectors & 0xff;
-                c->Request.CDB[14] = c->Request.CDB[15] = 0;
+                printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
+                BUG();
         }
 
         spin_lock_irq(q->queue_lock);