[PATCH] md: fix various bugs with aligned reads in RAID5
[linux-2.6.git] / block / scsi_ioctl.c
index 24f7af9..65c6a3c 100644 (file)
@@ -223,12 +223,12 @@ static int verify_command(struct file *file, unsigned char *cmd)
 static int sg_io(struct file *file, request_queue_t *q,
                struct gendisk *bd_disk, struct sg_io_hdr *hdr)
 {
-       unsigned long start_time;
+       unsigned long start_time, timeout;
        int writing = 0, ret = 0;
        struct request *rq;
-       struct bio *bio;
        char sense[SCSI_SENSE_BUFFERSIZE];
        unsigned char cmd[BLK_MAX_CDB];
+       struct bio *bio;
 
        if (hdr->interface_id != 'S')
                return -EINVAL;
@@ -246,10 +246,10 @@ static int sg_io(struct file *file, request_queue_t *q,
                switch (hdr->dxfer_direction) {
                default:
                        return -EINVAL;
-               case SG_DXFER_TO_FROM_DEV:
                case SG_DXFER_TO_DEV:
                        writing = 1;
                        break;
+               case SG_DXFER_TO_FROM_DEV:
                case SG_DXFER_FROM_DEV:
                        break;
                }
@@ -258,6 +258,26 @@ static int sg_io(struct file *file, request_queue_t *q,
        if (!rq)
                return -ENOMEM;
 
+       /*
+        * fill in request structure
+        */
+       rq->cmd_len = hdr->cmd_len;
+       memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
+       memcpy(rq->cmd, cmd, hdr->cmd_len);
+
+       memset(sense, 0, sizeof(sense));
+       rq->sense = sense;
+       rq->sense_len = 0;
+
+       rq->cmd_type = REQ_TYPE_BLOCK_PC;
+
+       timeout = msecs_to_jiffies(hdr->timeout);
+       rq->timeout = (timeout < INT_MAX) ? timeout : INT_MAX;
+       if (!rq->timeout)
+               rq->timeout = q->sg_timeout;
+       if (!rq->timeout)
+               rq->timeout = BLK_DEFAULT_TIMEOUT;
+
        if (hdr->iovec_count) {
                const int size = sizeof(struct sg_iovec) * hdr->iovec_count;
                struct sg_iovec *iov;
@@ -274,7 +294,8 @@ static int sg_io(struct file *file, request_queue_t *q,
                        goto out;
                }
 
-               ret = blk_rq_map_user_iov(q, rq, iov, hdr->iovec_count);
+               ret = blk_rq_map_user_iov(q, rq, iov, hdr->iovec_count,
+                                         hdr->dxfer_len);
                kfree(iov);
        } else if (hdr->dxfer_len)
                ret = blk_rq_map_user(q, rq, hdr->dxferp, hdr->dxfer_len);
@@ -282,34 +303,7 @@ static int sg_io(struct file *file, request_queue_t *q,
        if (ret)
                goto out;
 
-       /*
-        * fill in request structure
-        */
-       rq->cmd_len = hdr->cmd_len;
-       memcpy(rq->cmd, cmd, hdr->cmd_len);
-       if (sizeof(rq->cmd) != hdr->cmd_len)
-               memset(rq->cmd + hdr->cmd_len, 0, sizeof(rq->cmd) - hdr->cmd_len);
-
-       memset(sense, 0, sizeof(sense));
-       rq->sense = sense;
-       rq->sense_len = 0;
-
-       rq->flags |= REQ_BLOCK_PC;
        bio = rq->bio;
-
-       /*
-        * bounce this after holding a reference to the original bio, it's
-        * needed for proper unmapping
-        */
-       if (rq->bio)
-               blk_queue_bounce(q, &rq->bio);
-
-       rq->timeout = (hdr->timeout * HZ) / 1000;
-       if (!rq->timeout)
-               rq->timeout = q->sg_timeout;
-       if (!rq->timeout)
-               rq->timeout = BLK_DEFAULT_TIMEOUT;
-
        rq->retries = 0;
 
        start_time = jiffies;
@@ -340,7 +334,7 @@ static int sg_io(struct file *file, request_queue_t *q,
                        hdr->sb_len_wr = len;
        }
 
-       if (blk_rq_unmap_user(bio, hdr->dxfer_len))
+       if (blk_rq_unmap_user(bio))
                ret = -EFAULT;
 
        /* may not have succeeded, but output values written to control
@@ -350,16 +344,51 @@ out:
        return ret;
 }
 
+/**
+ * sg_scsi_ioctl  --  handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
+ * @file:      file this ioctl operates on (optional)
+ * @q:         request queue to send scsi commands down
+ * @disk:      gendisk to operate on (option)
+ * @sic:       userspace structure describing the command to perform
+ *
+ * Send down the scsi command described by @sic to the device below
+ * the request queue @q.  If @file is non-NULL it's used to perform
+ * fine-grained permission checks that allow users to send down
+ * non-destructive SCSI commands.  If the caller has a struct gendisk
+ * available it should be passed in as @disk to allow the low level
+ * driver to use the information contained in it.  A non-NULL @disk
+ * is only allowed if the caller knows that the low level driver doesn't
+ * need it (e.g. in the scsi subsystem).
+ *
+ * Notes:
+ *   -  This interface is deprecated - users should use the SG_IO
+ *      interface instead, as this is a more flexible approach to
+ *      performing SCSI commands on a device.
+ *   -  The SCSI command length is determined by examining the 1st byte
+ *      of the given command. There is no way to override this.
+ *   -  Data transfers are limited to PAGE_SIZE
+ *   -  The length (x + y) must be at least OMAX_SB_LEN bytes long to
+ *      accommodate the sense buffer when an error occurs.
+ *      The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
+ *      old code will not be surprised.
+ *   -  If a Unix error occurs (e.g. ENOMEM) then the user will receive
+ *      a negative return and the Unix error code in 'errno'.
+ *      If the SCSI command succeeds then 0 is returned.
+ *      Positive numbers returned are the compacted SCSI error codes (4
+ *      bytes in one int) where the lowest byte is the SCSI status.
+ */
 #define OMAX_SB_LEN 16          /* For backward compatibility */
-
-static int sg_scsi_ioctl(struct file *file, request_queue_t *q,
-                        struct gendisk *bd_disk, Scsi_Ioctl_Command __user *sic)
+int sg_scsi_ioctl(struct file *file, struct request_queue *q,
+                 struct gendisk *disk, struct scsi_ioctl_command __user *sic)
 {
        struct request *rq;
        int err;
        unsigned int in_len, out_len, bytes, opcode, cmdlen;
        char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];
 
+       if (!sic)
+               return -EINVAL;
+
        /*
         * get in an out lengths, verify they don't exceed a page worth of data
         */
@@ -393,45 +422,53 @@ static int sg_scsi_ioctl(struct file *file, request_queue_t *q,
        if (copy_from_user(rq->cmd, sic->data, cmdlen))
                goto error;
 
-       if (copy_from_user(buffer, sic->data + cmdlen, in_len))
+       if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
                goto error;
 
        err = verify_command(file, rq->cmd);
        if (err)
                goto error;
 
+       /* default.  possible overriden later */
+       rq->retries = 5;
+
        switch (opcode) {
-               case SEND_DIAGNOSTIC:
-               case FORMAT_UNIT:
-                       rq->timeout = FORMAT_UNIT_TIMEOUT;
-                       break;
-               case START_STOP:
-                       rq->timeout = START_STOP_TIMEOUT;
-                       break;
-               case MOVE_MEDIUM:
-                       rq->timeout = MOVE_MEDIUM_TIMEOUT;
-                       break;
-               case READ_ELEMENT_STATUS:
-                       rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
-                       break;
-               case READ_DEFECT_DATA:
-                       rq->timeout = READ_DEFECT_DATA_TIMEOUT;
-                       break;
-               default:
-                       rq->timeout = BLK_DEFAULT_TIMEOUT;
-                       break;
+       case SEND_DIAGNOSTIC:
+       case FORMAT_UNIT:
+               rq->timeout = FORMAT_UNIT_TIMEOUT;
+               rq->retries = 1;
+               break;
+       case START_STOP:
+               rq->timeout = START_STOP_TIMEOUT;
+               break;
+       case MOVE_MEDIUM:
+               rq->timeout = MOVE_MEDIUM_TIMEOUT;
+               break;
+       case READ_ELEMENT_STATUS:
+               rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
+               break;
+       case READ_DEFECT_DATA:
+               rq->timeout = READ_DEFECT_DATA_TIMEOUT;
+               rq->retries = 1;
+               break;
+       default:
+               rq->timeout = BLK_DEFAULT_TIMEOUT;
+               break;
+       }
+
+       if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) {
+               err = DRIVER_ERROR << 24;
+               goto out;
        }
 
        memset(sense, 0, sizeof(sense));
        rq->sense = sense;
        rq->sense_len = 0;
+       rq->cmd_type = REQ_TYPE_BLOCK_PC;
 
-       rq->data = buffer;
-       rq->data_len = bytes;
-       rq->flags |= REQ_BLOCK_PC;
-       rq->retries = 0;
+       blk_execute_rq(q, disk, rq, 0);
 
-       blk_execute_rq(q, bd_disk, rq, 0);
+out:
        err = rq->errors & 0xff;        /* only 8 bit SCSI status */
        if (err) {
                if (rq->sense_len && rq->sense) {
@@ -450,7 +487,7 @@ error:
        blk_put_request(rq);
        return err;
 }
-
+EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
 
 /* Send basic block requests */
 static int __blk_send_generic(request_queue_t *q, struct gendisk *bd_disk, int cmd, int data)
@@ -459,7 +496,7 @@ static int __blk_send_generic(request_queue_t *q, struct gendisk *bd_disk, int c
        int err;
 
        rq = blk_get_request(q, WRITE, __GFP_WAIT);
-       rq->flags |= REQ_BLOCK_PC;
+       rq->cmd_type = REQ_TYPE_BLOCK_PC;
        rq->data = NULL;
        rq->data_len = 0;
        rq->timeout = BLK_DEFAULT_TIMEOUT;