block: add blk_rq_set_block_pc()
authorJens Axboe <axboe@fb.com>
Fri, 6 Jun 2014 13:57:37 +0000 (07:57 -0600)
committerJens Axboe <axboe@fb.com>
Fri, 6 Jun 2014 13:57:37 +0000 (07:57 -0600)
With the optimizations around not clearing the full request at alloc
time, we are leaving some of the needed init for REQ_TYPE_BLOCK_PC
up to the user allocating the request.

Add a blk_rq_set_block_pc() that sets the command type to
REQ_TYPE_BLOCK_PC, and properly initializes the members associated
with this type of request. Update callers to use this function instead
of manipulating rq->cmd_type directly.

Includes fixes from Christoph Hellwig <hch@lst.de> for my half-assed
attempt.

Signed-off-by: Jens Axboe <axboe@fb.com>
17 files changed:
block/blk-core.c
block/bsg.c
block/scsi_ioctl.c
drivers/block/pktcdvd.c
drivers/cdrom/cdrom.c
drivers/scsi/device_handler/scsi_dh_alua.c
drivers/scsi/device_handler/scsi_dh_emc.c
drivers/scsi/device_handler/scsi_dh_hp_sw.c
drivers/scsi/device_handler/scsi_dh_rdac.c
drivers/scsi/osd/osd_initiator.c
drivers/scsi/osst.c
drivers/scsi/scsi_error.c
drivers/scsi/scsi_lib.c
drivers/scsi/sg.c
drivers/scsi/st.c
drivers/target/target_core_pscsi.c
include/linux/blkdev.h

index 40d654861c33e545dd79da5ce5a6dff40057e703..9aca8c71e70b0bf8d8936462f1517a62da6c8432 100644 (file)
@@ -1218,6 +1218,8 @@ struct request *blk_make_request(struct request_queue *q, struct bio *bio,
        if (unlikely(!rq))
                return ERR_PTR(-ENOMEM);
 
+       blk_rq_set_block_pc(rq);
+
        for_each_bio(bio) {
                struct bio *bounce_bio = bio;
                int ret;
@@ -1234,6 +1236,22 @@ struct request *blk_make_request(struct request_queue *q, struct bio *bio,
 }
 EXPORT_SYMBOL(blk_make_request);
 
+/**
+ * blk_rq_set_block_pc - initialize a requeest to type BLOCK_PC
+ * @rq:                request to be initialized
+ *
+ */
+void blk_rq_set_block_pc(struct request *rq)
+{
+       rq->cmd_type = REQ_TYPE_BLOCK_PC;
+       rq->__data_len = 0;
+       rq->__sector = (sector_t) -1;
+       rq->bio = rq->biotail = NULL;
+       memset(rq->__cmd, 0, sizeof(rq->__cmd));
+       rq->cmd = rq->__cmd;
+}
+EXPORT_SYMBOL(blk_rq_set_block_pc);
+
 /**
  * blk_requeue_request - put a request back on queue
  * @q:         request queue where request should be inserted
index e5214c1480962e5d53c0f0ced44af571051d9654..ff46addde5d8e0877d390901bb6a91bac591bb13 100644 (file)
@@ -196,7 +196,6 @@ static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,
         * fill in request structure
         */
        rq->cmd_len = hdr->request_len;
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
 
        rq->timeout = msecs_to_jiffies(hdr->timeout);
        if (!rq->timeout)
@@ -273,6 +272,8 @@ bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,
        rq = blk_get_request(q, rw, GFP_KERNEL);
        if (!rq)
                return ERR_PTR(-ENOMEM);
+       blk_rq_set_block_pc(rq);
+
        ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm);
        if (ret)
                goto out;
index 9c28a5b38042bbd7e9904d00e2495afb6ee4517b..14695c6221c821588592f65fb72507daf230a358 100644 (file)
@@ -229,7 +229,6 @@ static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
         * fill in request structure
         */
        rq->cmd_len = hdr->cmd_len;
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
 
        rq->timeout = msecs_to_jiffies(hdr->timeout);
        if (!rq->timeout)
@@ -311,6 +310,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
        rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
        if (!rq)
                return -ENOMEM;
+       blk_rq_set_block_pc(rq);
 
        if (blk_fill_sghdr_rq(q, rq, hdr, mode)) {
                blk_put_request(rq);
@@ -491,7 +491,7 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
        memset(sense, 0, sizeof(sense));
        rq->sense = sense;
        rq->sense_len = 0;
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
+       blk_rq_set_block_pc(rq);
 
        blk_execute_rq(q, disk, rq, 0);
 
@@ -524,7 +524,7 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
        int err;
 
        rq = blk_get_request(q, WRITE, __GFP_WAIT);
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
+       blk_rq_set_block_pc(rq);
        rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
        rq->cmd[0] = cmd;
        rq->cmd[4] = data;
index ef166ad2dbadc37bdd58a4e055409898291eea82..758ac442c5b5dd0e8c1d2e2689ac1a0d8c06604d 100644 (file)
@@ -704,6 +704,7 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
 
        rq = blk_get_request(q, (cgc->data_direction == CGC_DATA_WRITE) ?
                             WRITE : READ, __GFP_WAIT);
+       blk_rq_set_block_pc(rq);
 
        if (cgc->buflen) {
                ret = blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen,
@@ -716,7 +717,6 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
        memcpy(rq->cmd, cgc->cmd, CDROM_PACKET_SIZE);
 
        rq->timeout = 60*HZ;
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
        if (cgc->quiet)
                rq->cmd_flags |= REQ_QUIET;
 
index 49ac5662585b8d665ab6b6b6b659f2984e7bc5ad..0f40c95049c089f801fb262d86cfac503acb9dfd 100644 (file)
@@ -2184,6 +2184,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
                        ret = -ENOMEM;
                        break;
                }
+               blk_rq_set_block_pc(rq);
 
                ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
                if (ret) {
@@ -2203,7 +2204,6 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
                rq->cmd[9] = 0xf8;
 
                rq->cmd_len = 12;
-               rq->cmd_type = REQ_TYPE_BLOCK_PC;
                rq->timeout = 60 * HZ;
                bio = rq->bio;
 
index 5248c888552bcbdf8b5d53922e9218b4eb67e308..7bcf67eec921e5fb0fde14b6cc2097c09b1b4879 100644 (file)
@@ -120,6 +120,7 @@ static struct request *get_alua_req(struct scsi_device *sdev,
                            "%s: blk_get_request failed\n", __func__);
                return NULL;
        }
+       blk_rq_set_block_pc(rq);
 
        if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
                blk_put_request(rq);
@@ -128,7 +129,6 @@ static struct request *get_alua_req(struct scsi_device *sdev,
                return NULL;
        }
 
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
        rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
                         REQ_FAILFAST_DRIVER;
        rq->retries = ALUA_FAILOVER_RETRIES;
index e1c8be06de9de2f50dd608f0ec27f7bf81617adb..6f07f7fe3aa11e3603bad3858a817a0c485f26e0 100644 (file)
@@ -280,6 +280,7 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
                return NULL;
        }
 
+       blk_rq_set_block_pc(rq);
        rq->cmd_len = COMMAND_SIZE(cmd);
        rq->cmd[0] = cmd;
 
@@ -304,7 +305,6 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
                break;
        }
 
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
        rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
                         REQ_FAILFAST_DRIVER;
        rq->timeout = CLARIION_TIMEOUT;
index 084062bb8ee9de341ded2d0bb2d1b4b2ea897ecb..e9d9fea9e272baf797bf5e95d5f729e29eae90eb 100644 (file)
@@ -120,7 +120,7 @@ retry:
        if (!req)
                return SCSI_DH_RES_TEMP_UNAVAIL;
 
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
+       blk_rq_set_block_pc(req);
        req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
                          REQ_FAILFAST_DRIVER;
        req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
@@ -250,7 +250,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
        if (!req)
                return SCSI_DH_RES_TEMP_UNAVAIL;
 
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
+       blk_rq_set_block_pc(req);
        req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
                          REQ_FAILFAST_DRIVER;
        req->cmd_len = COMMAND_SIZE(START_STOP);
index 4b9cf93f3fb6274b7066c75d170b71a8f3bb5b2e..826069db9848e08d1b928986387484f23da5abdb 100644 (file)
@@ -279,6 +279,7 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
                                "get_rdac_req: blk_get_request failed.\n");
                return NULL;
        }
+       blk_rq_set_block_pc(rq);
 
        if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
                blk_put_request(rq);
@@ -287,7 +288,6 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
                return NULL;
        }
 
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
        rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
                         REQ_FAILFAST_DRIVER;
        rq->retries = RDAC_RETRIES;
index bac04c2335aaf997c73e7b3b8b8a08129bfca455..5f4cbf0c47592287fbc3c1a5208fbb15fc9a4b05 100644 (file)
@@ -1570,6 +1570,7 @@ static struct request *_make_request(struct request_queue *q, bool has_write,
                if (unlikely(!req))
                        return ERR_PTR(-ENOMEM);
 
+               blk_rq_set_block_pc(req);
                return req;
        }
 }
@@ -1590,7 +1591,6 @@ static int _init_blk_request(struct osd_request *or,
        }
 
        or->request = req;
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
        req->cmd_flags |= REQ_QUIET;
 
        req->timeout = or->timeout;
@@ -1608,7 +1608,7 @@ static int _init_blk_request(struct osd_request *or,
                                ret = PTR_ERR(req);
                                goto out;
                        }
-                       req->cmd_type = REQ_TYPE_BLOCK_PC;
+                       blk_rq_set_block_pc(req);
                        or->in.req = or->request->next_rq = req;
                }
        } else if (has_in)
index 21883a2d6324b19202446bb1d7107d59ed2908aa..0727ea7cc3874633c863702794a90c36024af98e 100644 (file)
@@ -365,7 +365,7 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
        if (!req)
                return DRIVER_ERROR << 24;
 
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
+       blk_rq_set_block_pc(req);
        req->cmd_flags |= REQ_QUIET;
 
        SRpnt->bio = NULL;
index f17aa7aa78796e7f6d358b8cd5f68fd43cfee4d4..af624619d547243f00f970ee9fc6d68d7f3ac391 100644 (file)
@@ -1951,6 +1951,8 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
         */
        req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL);
 
+       blk_rq_set_block_pc(req);
+
        req->cmd[0] = ALLOW_MEDIUM_REMOVAL;
        req->cmd[1] = 0;
        req->cmd[2] = 0;
@@ -1960,7 +1962,6 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
 
        req->cmd_len = COMMAND_SIZE(req->cmd[0]);
 
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
        req->cmd_flags |= REQ_QUIET;
        req->timeout = 10 * HZ;
        req->retries = 5;
index a0c95cac91f0fe55681830af4477e9513ec19a32..c3c1697b143e1c4b8a0af3d2426faf2610dacdc7 100644 (file)
@@ -195,6 +195,7 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
        req = blk_get_request(sdev->request_queue, write, __GFP_WAIT);
        if (!req)
                return ret;
+       blk_rq_set_block_pc(req);
 
        if (bufflen &&  blk_rq_map_kern(sdev->request_queue, req,
                                        buffer, bufflen, __GFP_WAIT))
@@ -206,7 +207,6 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
        req->sense_len = 0;
        req->retries = retries;
        req->timeout = timeout;
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
        req->cmd_flags |= flags | REQ_QUIET | REQ_PREEMPT;
 
        /*
index df5e961484e108312f6f01765882dd4319d584f7..53268aaba5597f5a6acc5995f4cafaf39cfa338b 100644 (file)
@@ -1653,10 +1653,9 @@ static int sg_start_req(Sg_request *srp, unsigned char *cmd)
        if (!rq)
                return -ENOMEM;
 
+       blk_rq_set_block_pc(rq);
        memcpy(rq->cmd, cmd, hp->cmd_len);
-
        rq->cmd_len = hp->cmd_len;
-       rq->cmd_type = REQ_TYPE_BLOCK_PC;
 
        srp->rq = rq;
        rq->end_io_data = srp;
index afc834e172c6429310a215f133b69306b77fa21b..14eb4b256a03a3378c65cba170f6507c707276cc 100644 (file)
@@ -484,7 +484,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
        if (!req)
                return DRIVER_ERROR << 24;
 
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
+       blk_rq_set_block_pc(req);
        req->cmd_flags |= REQ_QUIET;
 
        mdata->null_mapped = 1;
index 0f199f6a07385e6ea03d4c12da24863cd7e4f7cd..94d00df28f395e81523c43b8ba6ae4e7028b2cc7 100644 (file)
@@ -1055,6 +1055,8 @@ pscsi_execute_cmd(struct se_cmd *cmd)
                        ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                        goto fail;
                }
+
+               blk_rq_set_block_pc(req);
        } else {
                BUG_ON(!cmd->data_length);
 
@@ -1071,7 +1073,6 @@ pscsi_execute_cmd(struct se_cmd *cmd)
                }
        }
 
-       req->cmd_type = REQ_TYPE_BLOCK_PC;
        req->end_io = pscsi_req_done;
        req->end_io_data = cmd;
        req->cmd_len = scsi_command_size(pt->pscsi_cdb);
index dc2c703f05fd1390fb3d1468035ecfccf9eeffd8..31e11051f1ba3b8c0b04170f7e235a01b9b420c9 100644 (file)
@@ -796,6 +796,7 @@ extern void __blk_put_request(struct request_queue *, struct request *);
 extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
 extern struct request *blk_make_request(struct request_queue *, struct bio *,
                                        gfp_t);
+extern void blk_rq_set_block_pc(struct request *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
 extern void blk_add_request_payload(struct request *rq, struct page *page,
                unsigned int len);