sched/headers: Prepare to remove <linux/cred.h> inclusion from <linux/sched.h>

[mirror_ubuntu-artful-kernel.git] / block / scsi_ioctl.c

diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index c2b64923ab66d8d89b6e92be71fe898fc834baa2..2a2fc768b27ad81583424252f13b89303269b755 100644 (file)
--- 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')
@@ -318,14 +321,16 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
                at_head = 1;
 
        ret = -ENOMEM;
-       rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
+       rq = blk_get_request(q, writing ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN,
+                       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 +362,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 +377,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 +421,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;
@@ -447,12 +449,14 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
 
        }
 
-       rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_RECLAIM);
+       rq = blk_get_request(q, in_len ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN,
+                       __GFP_RECLAIM);
        if (IS_ERR(rq)) {
                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 +464,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 +507,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 {
@@ -539,14 +539,14 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
        struct request *rq;
        int err;
 
-       rq = blk_get_request(q, WRITE, __GFP_RECLAIM);
+       rq = blk_get_request(q, REQ_OP_SCSI_OUT, __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 +743,17 @@ 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);
+
+       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);