block: split scsi_request out of struct request

And require all drivers that want to support BLOCK_PC to allocate it
as the first thing of their private data.  To support this the legacy
IDE and BSG code is switched to set cmd_size on their queues to let
the block layer allocate the additional space.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@fb.com>

1 files changed, 43 insertions, 33 deletions

diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index c2b64923ab66..7edf44f25e08 100644
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -230,15 +230,17 @@ EXPORT_SYMBOL(blk_verify_command);
 static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
                              struct sg_io_hdr *hdr, fmode_t mode)
 {
-        if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
+        struct scsi_request *req = scsi_req(rq);
+
+        if (copy_from_user(req->cmd, hdr->cmdp, hdr->cmd_len))
                 return -EFAULT;
-        if (blk_verify_command(rq->cmd, mode & FMODE_WRITE))
+        if (blk_verify_command(req->cmd, mode & FMODE_WRITE))
                 return -EPERM;
 
         /*
          * fill in request structure
          */
-        rq->cmd_len = hdr->cmd_len;
+        req->cmd_len = hdr->cmd_len;
 
         rq->timeout = msecs_to_jiffies(hdr->timeout);
         if (!rq->timeout)
@@ -254,6 +256,7 @@ static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
 static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
                                  struct bio *bio)
 {
+        struct scsi_request *req = scsi_req(rq);
         int r, ret = 0;
 
         /*
@@ -267,13 +270,13 @@ static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
         hdr->info = 0;
         if (hdr->masked_status || hdr->host_status || hdr->driver_status)
                 hdr->info |= SG_INFO_CHECK;
-        hdr->resid = rq->resid_len;
+        hdr->resid = req->resid_len;
         hdr->sb_len_wr = 0;
 
-        if (rq->sense_len && hdr->sbp) {
-                int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len);
+        if (req->sense_len && hdr->sbp) {
+                int len = min((unsigned int) hdr->mx_sb_len, req->sense_len);
 
-                if (!copy_to_user(hdr->sbp, rq->sense, len))
+                if (!copy_to_user(hdr->sbp, req->sense, len))
                         hdr->sb_len_wr = len;
                 else
                         ret = -EFAULT;
@@ -294,7 +297,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
         int writing = 0;
         int at_head = 0;
         struct request *rq;
-        char sense[SCSI_SENSE_BUFFERSIZE];
+        struct scsi_request *req;
         struct bio *bio;
 
         if (hdr->interface_id != 'S')
@@ -321,11 +324,12 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
         rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
         if (IS_ERR(rq))
                 return PTR_ERR(rq);
-        blk_rq_set_block_pc(rq);
+        req = scsi_req(rq);
+        scsi_req_init(rq);
 
         if (hdr->cmd_len > BLK_MAX_CDB) {
-                rq->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
-                if (!rq->cmd)
+                req->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
+                if (!req->cmd)
                         goto out_put_request;
         }
 
@@ -357,9 +361,6 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
                 goto out_free_cdb;
 
         bio = rq->bio;
-        memset(sense, 0, sizeof(sense));
-        rq->sense = sense;
-        rq->sense_len = 0;
         rq->retries = 0;
 
         start_time = jiffies;
@@ -375,8 +376,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
         ret = blk_complete_sghdr_rq(rq, hdr, bio);
 
 out_free_cdb:
-        if (rq->cmd != rq->__cmd)
-                kfree(rq->cmd);
+        scsi_req_free_cmd(req);
 out_put_request:
         blk_put_request(rq);
         return ret;
@@ -420,9 +420,10 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
                 struct scsi_ioctl_command __user *sic)
 {
         struct request *rq;
+        struct scsi_request *req;
         int err;
         unsigned int in_len, out_len, bytes, opcode, cmdlen;
-        char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];
+        char *buffer = NULL;
 
         if (!sic)
                 return -EINVAL;
@@ -452,7 +453,8 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
                 err = PTR_ERR(rq);
                 goto error_free_buffer;
         }
-        blk_rq_set_block_pc(rq);
+        req = scsi_req(rq);
+        scsi_req_init(rq);
 
         cmdlen = COMMAND_SIZE(opcode);
 
@@ -460,14 +462,14 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
          * get command and data to send to device, if any
          */
         err = -EFAULT;
-        rq->cmd_len = cmdlen;
-        if (copy_from_user(rq->cmd, sic->data, cmdlen))
+        req->cmd_len = cmdlen;
+        if (copy_from_user(req->cmd, sic->data, cmdlen))
                 goto error;
 
         if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
                 goto error;
 
-        err = blk_verify_command(rq->cmd, mode & FMODE_WRITE);
+        err = blk_verify_command(req->cmd, mode & FMODE_WRITE);
         if (err)
                 goto error;
 
@@ -503,18 +505,14 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
                 goto error;
         }
 
-        memset(sense, 0, sizeof(sense));
-        rq->sense = sense;
-        rq->sense_len = 0;
-
         blk_execute_rq(q, disk, rq, 0);
 
         err = rq->errors & 0xff;        /* only 8 bit SCSI status */
         if (err) {
-                if (rq->sense_len && rq->sense) {
-                        bytes = (OMAX_SB_LEN > rq->sense_len) ?
-                                rq->sense_len : OMAX_SB_LEN;
-                        if (copy_to_user(sic->data, rq->sense, bytes))
+                if (req->sense_len && req->sense) {
+                        bytes = (OMAX_SB_LEN > req->sense_len) ?
+                                req->sense_len : OMAX_SB_LEN;
+                        if (copy_to_user(sic->data, req->sense, bytes))
                                 err = -EFAULT;
                 }
         } else {
@@ -542,11 +540,11 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
         rq = blk_get_request(q, WRITE, __GFP_RECLAIM);
         if (IS_ERR(rq))
                 return PTR_ERR(rq);
-        blk_rq_set_block_pc(rq);
+        scsi_req_init(rq);
         rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
-        rq->cmd[0] = cmd;
-        rq->cmd[4] = data;
-        rq->cmd_len = 6;
+        scsi_req(rq)->cmd[0] = cmd;
+        scsi_req(rq)->cmd[4] = data;
+        scsi_req(rq)->cmd_len = 6;
         err = blk_execute_rq(q, bd_disk, rq, 0);
         blk_put_request(rq);
 
@@ -743,6 +741,18 @@ int scsi_cmd_blk_ioctl(struct block_device *bd, fmode_t mode,
 }
 EXPORT_SYMBOL(scsi_cmd_blk_ioctl);
 
+void scsi_req_init(struct request *rq)
+{
+        struct scsi_request *req = scsi_req(rq);
+
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
+        memset(req->__cmd, 0, sizeof(req->__cmd));
+        req->cmd = req->__cmd;
+        req->cmd_len = BLK_MAX_CDB;
+        req->sense_len = 0;
+}
+EXPORT_SYMBOL(scsi_req_init);
+
 static int __init blk_scsi_ioctl_init(void)
 {
         blk_set_cmd_filter_defaults(&blk_default_cmd_filter);