summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--block/blk-core.c31
-rw-r--r--block/blk-exec.c17
-rw-r--r--block/blk-mq.c10
-rw-r--r--block/bsg-lib.c34
-rw-r--r--block/bsg.c47
-rw-r--r--block/scsi_ioctl.c76
-rw-r--r--drivers/ata/libata-scsi.c2
-rw-r--r--drivers/block/cciss.c28
-rw-r--r--drivers/block/pktcdvd.c6
-rw-r--r--drivers/block/virtio_blk.c11
-rw-r--r--drivers/cdrom/cdrom.c32
-rw-r--r--drivers/ide/ide-atapi.c43
-rw-r--r--drivers/ide/ide-cd.c91
-rw-r--r--drivers/ide/ide-cd_ioctl.c1
-rw-r--r--drivers/ide/ide-cd_verbose.c6
-rw-r--r--drivers/ide/ide-devsets.c9
-rw-r--r--drivers/ide/ide-disk.c1
-rw-r--r--drivers/ide/ide-eh.c2
-rw-r--r--drivers/ide/ide-floppy.c4
-rw-r--r--drivers/ide/ide-io.c3
-rw-r--r--drivers/ide/ide-ioctls.c6
-rw-r--r--drivers/ide/ide-park.c12
-rw-r--r--drivers/ide/ide-pm.c2
-rw-r--r--drivers/ide/ide-probe.c36
-rw-r--r--drivers/ide/ide-tape.c32
-rw-r--r--drivers/ide/ide-taskfile.c1
-rw-r--r--drivers/ide/sis5513.c2
-rw-r--r--drivers/message/fusion/mptsas.c8
-rw-r--r--drivers/scsi/libfc/fc_lport.c2
-rw-r--r--drivers/scsi/libsas/sas_expander.c8
-rw-r--r--drivers/scsi/libsas/sas_host_smp.c38
-rw-r--r--drivers/scsi/mpt3sas/mpt3sas_transport.c8
-rw-r--r--drivers/scsi/osd/osd_initiator.c19
-rw-r--r--drivers/scsi/osst.c15
-rw-r--r--drivers/scsi/qla2xxx/qla_bsg.c2
-rw-r--r--drivers/scsi/qla2xxx/qla_isr.c6
-rw-r--r--drivers/scsi/qla2xxx/qla_mr.c2
-rw-r--r--drivers/scsi/scsi_error.c22
-rw-r--r--drivers/scsi/scsi_lib.c51
-rw-r--r--drivers/scsi/scsi_transport_sas.c5
-rw-r--r--drivers/scsi/sd.c4
-rw-r--r--drivers/scsi/sg.c30
-rw-r--r--drivers/scsi/st.c22
-rw-r--r--drivers/target/target_core_pscsi.c11
-rw-r--r--fs/nfsd/blocklayout.c17
-rw-r--r--include/linux/blkdev.h13
-rw-r--r--include/linux/ide.h8
-rw-r--r--include/scsi/scsi_cmnd.h2
-rw-r--r--include/scsi/scsi_request.h30
49 files changed, 458 insertions, 410 deletions
diff --git a/block/blk-core.c b/block/blk-core.c
index 0a485ad802c9..f3bc083d4c14 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -132,8 +132,6 @@ void blk_rq_init(struct request_queue *q, struct request *rq)
132 rq->__sector = (sector_t) -1; 132 rq->__sector = (sector_t) -1;
133 INIT_HLIST_NODE(&rq->hash); 133 INIT_HLIST_NODE(&rq->hash);
134 RB_CLEAR_NODE(&rq->rb_node); 134 RB_CLEAR_NODE(&rq->rb_node);
135 rq->cmd = rq->__cmd;
136 rq->cmd_len = BLK_MAX_CDB;
137 rq->tag = -1; 135 rq->tag = -1;
138 rq->internal_tag = -1; 136 rq->internal_tag = -1;
139 rq->start_time = jiffies; 137 rq->start_time = jiffies;
@@ -160,8 +158,6 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
160 158
161void blk_dump_rq_flags(struct request *rq, char *msg) 159void blk_dump_rq_flags(struct request *rq, char *msg)
162{ 160{
163 int bit;
164
165 printk(KERN_INFO "%s: dev %s: type=%x, flags=%llx\n", msg, 161 printk(KERN_INFO "%s: dev %s: type=%x, flags=%llx\n", msg,
166 rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->cmd_type, 162 rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->cmd_type,
167 (unsigned long long) rq->cmd_flags); 163 (unsigned long long) rq->cmd_flags);
@@ -171,13 +167,6 @@ void blk_dump_rq_flags(struct request *rq, char *msg)
171 blk_rq_sectors(rq), blk_rq_cur_sectors(rq)); 167 blk_rq_sectors(rq), blk_rq_cur_sectors(rq));
172 printk(KERN_INFO " bio %p, biotail %p, len %u\n", 168 printk(KERN_INFO " bio %p, biotail %p, len %u\n",
173 rq->bio, rq->biotail, blk_rq_bytes(rq)); 169 rq->bio, rq->biotail, blk_rq_bytes(rq));
174
175 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
176 printk(KERN_INFO " cdb: ");
177 for (bit = 0; bit < BLK_MAX_CDB; bit++)
178 printk("%02x ", rq->cmd[bit]);
179 printk("\n");
180 }
181} 170}
182EXPORT_SYMBOL(blk_dump_rq_flags); 171EXPORT_SYMBOL(blk_dump_rq_flags);
183 172
@@ -1316,18 +1305,6 @@ struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)
1316EXPORT_SYMBOL(blk_get_request); 1305EXPORT_SYMBOL(blk_get_request);
1317 1306
1318/** 1307/**
1319 * blk_rq_set_block_pc - initialize a request to type BLOCK_PC
1320 * @rq: request to be initialized
1321 *
1322 */
1323void blk_rq_set_block_pc(struct request *rq)
1324{
1325 rq->cmd_type = REQ_TYPE_BLOCK_PC;
1326 memset(rq->__cmd, 0, sizeof(rq->__cmd));
1327}
1328EXPORT_SYMBOL(blk_rq_set_block_pc);
1329
1330/**
1331 * blk_requeue_request - put a request back on queue 1308 * blk_requeue_request - put a request back on queue
1332 * @q: request queue where request should be inserted 1309 * @q: request queue where request should be inserted
1333 * @rq: request to be inserted 1310 * @rq: request to be inserted
@@ -2459,14 +2436,6 @@ void blk_start_request(struct request *req)
2459 wbt_issue(req->q->rq_wb, &req->issue_stat); 2436 wbt_issue(req->q->rq_wb, &req->issue_stat);
2460 } 2437 }
2461 2438
2462 /*
2463 * We are now handing the request to the hardware, initialize
2464 * resid_len to full count and add the timeout handler.
2465 */
2466 req->resid_len = blk_rq_bytes(req);
2467 if (unlikely(blk_bidi_rq(req)))
2468 req->next_rq->resid_len = blk_rq_bytes(req->next_rq);
2469
2470 BUG_ON(test_bit(REQ_ATOM_COMPLETE, &req->atomic_flags)); 2439 BUG_ON(test_bit(REQ_ATOM_COMPLETE, &req->atomic_flags));
2471 blk_add_timer(req); 2440 blk_add_timer(req);
2472} 2441}
diff --git a/block/blk-exec.c b/block/blk-exec.c
index ed1f10165268..ed51800f4b44 100644
--- a/block/blk-exec.c
+++ b/block/blk-exec.c
@@ -11,11 +11,6 @@
11#include "blk.h" 11#include "blk.h"
12#include "blk-mq-sched.h" 12#include "blk-mq-sched.h"
13 13
14/*
15 * for max sense size
16 */
17#include <scsi/scsi_cmnd.h>
18
19/** 14/**
20 * blk_end_sync_rq - executes a completion event on a request 15 * blk_end_sync_rq - executes a completion event on a request
21 * @rq: request to complete 16 * @rq: request to complete
@@ -101,16 +96,9 @@ int blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk,
101 struct request *rq, int at_head) 96 struct request *rq, int at_head)
102{ 97{
103 DECLARE_COMPLETION_ONSTACK(wait); 98 DECLARE_COMPLETION_ONSTACK(wait);
104 char sense[SCSI_SENSE_BUFFERSIZE];
105 int err = 0; 99 int err = 0;
106 unsigned long hang_check; 100 unsigned long hang_check;
107 101
108 if (!rq->sense) {
109 memset(sense, 0, sizeof(sense));
110 rq->sense = sense;
111 rq->sense_len = 0;
112 }
113
114 rq->end_io_data = &wait; 102 rq->end_io_data = &wait;
115 blk_execute_rq_nowait(q, bd_disk, rq, at_head, blk_end_sync_rq); 103 blk_execute_rq_nowait(q, bd_disk, rq, at_head, blk_end_sync_rq);
116 104
@@ -124,11 +112,6 @@ int blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk,
124 if (rq->errors) 112 if (rq->errors)
125 err = -EIO; 113 err = -EIO;
126 114
127 if (rq->sense == sense) {
128 rq->sense = NULL;
129 rq->sense_len = 0;
130 }
131
132 return err; 115 return err;
133} 116}
134EXPORT_SYMBOL(blk_execute_rq); 117EXPORT_SYMBOL(blk_execute_rq);
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 60dac10228fe..3d76e860f126 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -199,13 +199,7 @@ void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx,
199 rq->special = NULL; 199 rq->special = NULL;
200 /* tag was already set */ 200 /* tag was already set */
201 rq->errors = 0; 201 rq->errors = 0;
202
203 rq->cmd = rq->__cmd;
204
205 rq->extra_len = 0; 202 rq->extra_len = 0;
206 rq->sense_len = 0;
207 rq->resid_len = 0;
208 rq->sense = NULL;
209 203
210 INIT_LIST_HEAD(&rq->timeout_list); 204 INIT_LIST_HEAD(&rq->timeout_list);
211 rq->timeout = 0; 205 rq->timeout = 0;
@@ -487,10 +481,6 @@ void blk_mq_start_request(struct request *rq)
487 481
488 trace_block_rq_issue(q, rq); 482 trace_block_rq_issue(q, rq);
489 483
490 rq->resid_len = blk_rq_bytes(rq);
491 if (unlikely(blk_bidi_rq(rq)))
492 rq->next_rq->resid_len = blk_rq_bytes(rq->next_rq);
493
494 if (test_bit(QUEUE_FLAG_STATS, &q->queue_flags)) { 484 if (test_bit(QUEUE_FLAG_STATS, &q->queue_flags)) {
495 blk_stat_set_issue_time(&rq->issue_stat); 485 blk_stat_set_issue_time(&rq->issue_stat);
496 rq->rq_flags |= RQF_STATS; 486 rq->rq_flags |= RQF_STATS;
diff --git a/block/bsg-lib.c b/block/bsg-lib.c
index c74acf426840..cd15f9dbb147 100644
--- a/block/bsg-lib.c
+++ b/block/bsg-lib.c
@@ -71,22 +71,24 @@ void bsg_job_done(struct bsg_job *job, int result,
71{ 71{
72 struct request *req = job->req; 72 struct request *req = job->req;
73 struct request *rsp = req->next_rq; 73 struct request *rsp = req->next_rq;
74 struct scsi_request *rq = scsi_req(req);
74 int err; 75 int err;
75 76
76 err = job->req->errors = result; 77 err = job->req->errors = result;
77 if (err < 0) 78 if (err < 0)
78 /* we're only returning the result field in the reply */ 79 /* we're only returning the result field in the reply */
79 job->req->sense_len = sizeof(u32); 80 rq->sense_len = sizeof(u32);
80 else 81 else
81 job->req->sense_len = job->reply_len; 82 rq->sense_len = job->reply_len;
82 /* we assume all request payload was transferred, residual == 0 */ 83 /* we assume all request payload was transferred, residual == 0 */
83 req->resid_len = 0; 84 rq->resid_len = 0;
84 85
85 if (rsp) { 86 if (rsp) {
86 WARN_ON(reply_payload_rcv_len > rsp->resid_len); 87 WARN_ON(reply_payload_rcv_len > scsi_req(rsp)->resid_len);
87 88
88 /* set reply (bidi) residual */ 89 /* set reply (bidi) residual */
89 rsp->resid_len -= min(reply_payload_rcv_len, rsp->resid_len); 90 scsi_req(rsp)->resid_len -=
91 min(reply_payload_rcv_len, scsi_req(rsp)->resid_len);
90 } 92 }
91 blk_complete_request(req); 93 blk_complete_request(req);
92} 94}
@@ -113,6 +115,7 @@ static int bsg_map_buffer(struct bsg_buffer *buf, struct request *req)
113 if (!buf->sg_list) 115 if (!buf->sg_list)
114 return -ENOMEM; 116 return -ENOMEM;
115 sg_init_table(buf->sg_list, req->nr_phys_segments); 117 sg_init_table(buf->sg_list, req->nr_phys_segments);
118 scsi_req(req)->resid_len = blk_rq_bytes(req);
116 buf->sg_cnt = blk_rq_map_sg(req->q, req, buf->sg_list); 119 buf->sg_cnt = blk_rq_map_sg(req->q, req, buf->sg_list);
117 buf->payload_len = blk_rq_bytes(req); 120 buf->payload_len = blk_rq_bytes(req);
118 return 0; 121 return 0;
@@ -127,6 +130,7 @@ static int bsg_create_job(struct device *dev, struct request *req)
127{ 130{
128 struct request *rsp = req->next_rq; 131 struct request *rsp = req->next_rq;
129 struct request_queue *q = req->q; 132 struct request_queue *q = req->q;
133 struct scsi_request *rq = scsi_req(req);
130 struct bsg_job *job; 134 struct bsg_job *job;
131 int ret; 135 int ret;
132 136
@@ -140,9 +144,9 @@ static int bsg_create_job(struct device *dev, struct request *req)
140 job->req = req; 144 job->req = req;
141 if (q->bsg_job_size) 145 if (q->bsg_job_size)
142 job->dd_data = (void *)&job[1]; 146 job->dd_data = (void *)&job[1];
143 job->request = req->cmd; 147 job->request = rq->cmd;
144 job->request_len = req->cmd_len; 148 job->request_len = rq->cmd_len;
145 job->reply = req->sense; 149 job->reply = rq->sense;
146 job->reply_len = SCSI_SENSE_BUFFERSIZE; /* Size of sense buffer 150 job->reply_len = SCSI_SENSE_BUFFERSIZE; /* Size of sense buffer
147 * allocated */ 151 * allocated */
148 if (req->bio) { 152 if (req->bio) {
@@ -228,9 +232,15 @@ struct request_queue *bsg_setup_queue(struct device *dev, char *name,
228 struct request_queue *q; 232 struct request_queue *q;
229 int ret; 233 int ret;
230 234
231 q = blk_init_queue(bsg_request_fn, NULL); 235 q = blk_alloc_queue(GFP_KERNEL);
232 if (!q) 236 if (!q)
233 return ERR_PTR(-ENOMEM); 237 return ERR_PTR(-ENOMEM);
238 q->cmd_size = sizeof(struct scsi_request);
239 q->request_fn = bsg_request_fn;
240
241 ret = blk_init_allocated_queue(q);
242 if (ret)
243 goto out_cleanup_queue;
234 244
235 q->queuedata = dev; 245 q->queuedata = dev;
236 q->bsg_job_size = dd_job_size; 246 q->bsg_job_size = dd_job_size;
@@ -243,10 +253,12 @@ struct request_queue *bsg_setup_queue(struct device *dev, char *name,
243 if (ret) { 253 if (ret) {
244 printk(KERN_ERR "%s: bsg interface failed to " 254 printk(KERN_ERR "%s: bsg interface failed to "
245 "initialize - register queue\n", dev->kobj.name); 255 "initialize - register queue\n", dev->kobj.name);
246 blk_cleanup_queue(q); 256 goto out_cleanup_queue;
247 return ERR_PTR(ret);
248 } 257 }
249 258
250 return q; 259 return q;
260out_cleanup_queue:
261 blk_cleanup_queue(q);
262 return ERR_PTR(ret);
251} 263}
252EXPORT_SYMBOL_GPL(bsg_setup_queue); 264EXPORT_SYMBOL_GPL(bsg_setup_queue);
diff --git a/block/bsg.c b/block/bsg.c
index a57046de2f07..e34c3320956c 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -85,7 +85,6 @@ struct bsg_command {
85 struct bio *bidi_bio; 85 struct bio *bidi_bio;
86 int err; 86 int err;
87 struct sg_io_v4 hdr; 87 struct sg_io_v4 hdr;
88 char sense[SCSI_SENSE_BUFFERSIZE];
89}; 88};
90 89
91static void bsg_free_command(struct bsg_command *bc) 90static void bsg_free_command(struct bsg_command *bc)
@@ -140,18 +139,20 @@ static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,
140 struct sg_io_v4 *hdr, struct bsg_device *bd, 139 struct sg_io_v4 *hdr, struct bsg_device *bd,
141 fmode_t has_write_perm) 140 fmode_t has_write_perm)
142{ 141{
142 struct scsi_request *req = scsi_req(rq);
143
143 if (hdr->request_len > BLK_MAX_CDB) { 144 if (hdr->request_len > BLK_MAX_CDB) {
144 rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL); 145 req->cmd = kzalloc(hdr->request_len, GFP_KERNEL);
145 if (!rq->cmd) 146 if (!req->cmd)
146 return -ENOMEM; 147 return -ENOMEM;
147 } 148 }
148 149
149 if (copy_from_user(rq->cmd, (void __user *)(unsigned long)hdr->request, 150 if (copy_from_user(req->cmd, (void __user *)(unsigned long)hdr->request,
150 hdr->request_len)) 151 hdr->request_len))
151 return -EFAULT; 152 return -EFAULT;
152 153
153 if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) { 154 if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {
154 if (blk_verify_command(rq->cmd, has_write_perm)) 155 if (blk_verify_command(req->cmd, has_write_perm))
155 return -EPERM; 156 return -EPERM;
156 } else if (!capable(CAP_SYS_RAWIO)) 157 } else if (!capable(CAP_SYS_RAWIO))
157 return -EPERM; 158 return -EPERM;
@@ -159,7 +160,7 @@ static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,
159 /* 160 /*
160 * fill in request structure 161 * fill in request structure
161 */ 162 */
162 rq->cmd_len = hdr->request_len; 163 req->cmd_len = hdr->request_len;
163 164
164 rq->timeout = msecs_to_jiffies(hdr->timeout); 165 rq->timeout = msecs_to_jiffies(hdr->timeout);
165 if (!rq->timeout) 166 if (!rq->timeout)
@@ -205,8 +206,7 @@ bsg_validate_sgv4_hdr(struct sg_io_v4 *hdr, int *rw)
205 * map sg_io_v4 to a request. 206 * map sg_io_v4 to a request.
206 */ 207 */
207static struct request * 208static struct request *
208bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm, 209bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm)
209 u8 *sense)
210{ 210{
211 struct request_queue *q = bd->queue; 211 struct request_queue *q = bd->queue;
212 struct request *rq, *next_rq = NULL; 212 struct request *rq, *next_rq = NULL;
@@ -236,7 +236,7 @@ bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,
236 rq = blk_get_request(q, rw, GFP_KERNEL); 236 rq = blk_get_request(q, rw, GFP_KERNEL);
237 if (IS_ERR(rq)) 237 if (IS_ERR(rq))
238 return rq; 238 return rq;
239 blk_rq_set_block_pc(rq); 239 scsi_req_init(rq);
240 240
241 ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm); 241 ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm);
242 if (ret) 242 if (ret)
@@ -280,13 +280,9 @@ bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,
280 goto out; 280 goto out;
281 } 281 }
282 282
283 rq->sense = sense;
284 rq->sense_len = 0;
285
286 return rq; 283 return rq;
287out: 284out:
288 if (rq->cmd != rq->__cmd) 285 scsi_req_free_cmd(scsi_req(rq));
289 kfree(rq->cmd);
290 blk_put_request(rq); 286 blk_put_request(rq);
291 if (next_rq) { 287 if (next_rq) {
292 blk_rq_unmap_user(next_rq->bio); 288 blk_rq_unmap_user(next_rq->bio);
@@ -393,6 +389,7 @@ static struct bsg_command *bsg_get_done_cmd(struct bsg_device *bd)
393static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr, 389static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
394 struct bio *bio, struct bio *bidi_bio) 390 struct bio *bio, struct bio *bidi_bio)
395{ 391{
392 struct scsi_request *req = scsi_req(rq);
396 int ret = 0; 393 int ret = 0;
397 394
398 dprintk("rq %p bio %p 0x%x\n", rq, bio, rq->errors); 395 dprintk("rq %p bio %p 0x%x\n", rq, bio, rq->errors);
@@ -407,12 +404,12 @@ static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
407 hdr->info |= SG_INFO_CHECK; 404 hdr->info |= SG_INFO_CHECK;
408 hdr->response_len = 0; 405 hdr->response_len = 0;
409 406
410 if (rq->sense_len && hdr->response) { 407 if (req->sense_len && hdr->response) {
411 int len = min_t(unsigned int, hdr->max_response_len, 408 int len = min_t(unsigned int, hdr->max_response_len,
412 rq->sense_len); 409 req->sense_len);
413 410
414 ret = copy_to_user((void __user *)(unsigned long)hdr->response, 411 ret = copy_to_user((void __user *)(unsigned long)hdr->response,
415 rq->sense, len); 412 req->sense, len);
416 if (!ret) 413 if (!ret)
417 hdr->response_len = len; 414 hdr->response_len = len;
418 else 415 else
@@ -420,14 +417,14 @@ static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
420 } 417 }
421 418
422 if (rq->next_rq) { 419 if (rq->next_rq) {
423 hdr->dout_resid = rq->resid_len; 420 hdr->dout_resid = req->resid_len;
424 hdr->din_resid = rq->next_rq->resid_len; 421 hdr->din_resid = scsi_req(rq->next_rq)->resid_len;
425 blk_rq_unmap_user(bidi_bio); 422 blk_rq_unmap_user(bidi_bio);
426 blk_put_request(rq->next_rq); 423 blk_put_request(rq->next_rq);
427 } else if (rq_data_dir(rq) == READ) 424 } else if (rq_data_dir(rq) == READ)
428 hdr->din_resid = rq->resid_len; 425 hdr->din_resid = req->resid_len;
429 else 426 else
430 hdr->dout_resid = rq->resid_len; 427 hdr->dout_resid = req->resid_len;
431 428
432 /* 429 /*
433 * If the request generated a negative error number, return it 430 * If the request generated a negative error number, return it
@@ -439,8 +436,7 @@ static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
439 ret = rq->errors; 436 ret = rq->errors;
440 437
441 blk_rq_unmap_user(bio); 438 blk_rq_unmap_user(bio);
442 if (rq->cmd != rq->__cmd) 439 scsi_req_free_cmd(req);
443 kfree(rq->cmd);
444 blk_put_request(rq); 440 blk_put_request(rq);
445 441
446 return ret; 442 return ret;
@@ -625,7 +621,7 @@ static int __bsg_write(struct bsg_device *bd, const char __user *buf,
625 /* 621 /*
626 * get a request, fill in the blanks, and add to request queue 622 * get a request, fill in the blanks, and add to request queue
627 */ 623 */
628 rq = bsg_map_hdr(bd, &bc->hdr, has_write_perm, bc->sense); 624 rq = bsg_map_hdr(bd, &bc->hdr, has_write_perm);
629 if (IS_ERR(rq)) { 625 if (IS_ERR(rq)) {
630 ret = PTR_ERR(rq); 626 ret = PTR_ERR(rq);
631 rq = NULL; 627 rq = NULL;
@@ -911,12 +907,11 @@ static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
911 struct bio *bio, *bidi_bio = NULL; 907 struct bio *bio, *bidi_bio = NULL;
912 struct sg_io_v4 hdr; 908 struct sg_io_v4 hdr;
913 int at_head; 909 int at_head;
914 u8 sense[SCSI_SENSE_BUFFERSIZE];
915 910
916 if (copy_from_user(&hdr, uarg, sizeof(hdr))) 911 if (copy_from_user(&hdr, uarg, sizeof(hdr)))
917 return -EFAULT; 912 return -EFAULT;
918 913
919 rq = bsg_map_hdr(bd, &hdr, file->f_mode & FMODE_WRITE, sense); 914 rq = bsg_map_hdr(bd, &hdr, file->f_mode & FMODE_WRITE);
920 if (IS_ERR(rq)) 915 if (IS_ERR(rq))
921 return PTR_ERR(rq); 916 return PTR_ERR(rq);
922 917
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);
230static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq, 230static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
231 struct sg_io_hdr *hdr, fmode_t mode) 231 struct sg_io_hdr *hdr, fmode_t mode)
232{ 232{
233 if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len)) 233 struct scsi_request *req = scsi_req(rq);
234
235 if (copy_from_user(req->cmd, hdr->cmdp, hdr->cmd_len))
234 return -EFAULT; 236 return -EFAULT;
235 if (blk_verify_command(rq->cmd, mode & FMODE_WRITE)) 237 if (blk_verify_command(req->cmd, mode & FMODE_WRITE))
236 return -EPERM; 238 return -EPERM;
237 239
238 /* 240 /*
239 * fill in request structure 241 * fill in request structure
240 */ 242 */
241 rq->cmd_len = hdr->cmd_len; 243 req->cmd_len = hdr->cmd_len;
242 244
243 rq->timeout = msecs_to_jiffies(hdr->timeout); 245 rq->timeout = msecs_to_jiffies(hdr->timeout);
244 if (!rq->timeout) 246 if (!rq->timeout)
@@ -254,6 +256,7 @@ static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
254static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr, 256static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
255 struct bio *bio) 257 struct bio *bio)
256{ 258{
259 struct scsi_request *req = scsi_req(rq);
257 int r, ret = 0; 260 int r, ret = 0;
258 261
259 /* 262 /*
@@ -267,13 +270,13 @@ static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
267 hdr->info = 0; 270 hdr->info = 0;
268 if (hdr->masked_status || hdr->host_status || hdr->driver_status) 271 if (hdr->masked_status || hdr->host_status || hdr->driver_status)
269 hdr->info |= SG_INFO_CHECK; 272 hdr->info |= SG_INFO_CHECK;
270 hdr->resid = rq->resid_len; 273 hdr->resid = req->resid_len;
271 hdr->sb_len_wr = 0; 274 hdr->sb_len_wr = 0;
272 275
273 if (rq->sense_len && hdr->sbp) { 276 if (req->sense_len && hdr->sbp) {
274 int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len); 277 int len = min((unsigned int) hdr->mx_sb_len, req->sense_len);
275 278
276 if (!copy_to_user(hdr->sbp, rq->sense, len)) 279 if (!copy_to_user(hdr->sbp, req->sense, len))
277 hdr->sb_len_wr = len; 280 hdr->sb_len_wr = len;
278 else 281 else
279 ret = -EFAULT; 282 ret = -EFAULT;
@@ -294,7 +297,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
294 int writing = 0; 297 int writing = 0;
295 int at_head = 0; 298 int at_head = 0;
296 struct request *rq; 299 struct request *rq;
297 char sense[SCSI_SENSE_BUFFERSIZE]; 300 struct scsi_request *req;
298 struct bio *bio; 301 struct bio *bio;
299 302
300 if (hdr->interface_id != 'S') 303 if (hdr->interface_id != 'S')
@@ -321,11 +324,12 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
321 rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL); 324 rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
322 if (IS_ERR(rq)) 325 if (IS_ERR(rq))
323 return PTR_ERR(rq); 326 return PTR_ERR(rq);
324 blk_rq_set_block_pc(rq); 327 req = scsi_req(rq);
328 scsi_req_init(rq);
325 329
326 if (hdr->cmd_len > BLK_MAX_CDB) { 330 if (hdr->cmd_len > BLK_MAX_CDB) {
327 rq->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL); 331 req->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
328 if (!rq->cmd) 332 if (!req->cmd)
329 goto out_put_request; 333 goto out_put_request;
330 } 334 }
331 335
@@ -357,9 +361,6 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
357 goto out_free_cdb; 361 goto out_free_cdb;
358 362
359 bio = rq->bio; 363 bio = rq->bio;
360 memset(sense, 0, sizeof(sense));
361 rq->sense = sense;
362 rq->sense_len = 0;
363 rq->retries = 0; 364 rq->retries = 0;
364 365
365 start_time = jiffies; 366 start_time = jiffies;
@@ -375,8 +376,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
375 ret = blk_complete_sghdr_rq(rq, hdr, bio); 376 ret = blk_complete_sghdr_rq(rq, hdr, bio);
376 377
377out_free_cdb: 378out_free_cdb:
378 if (rq->cmd != rq->__cmd) 379 scsi_req_free_cmd(req);
379 kfree(rq->cmd);
380out_put_request: 380out_put_request:
381 blk_put_request(rq); 381 blk_put_request(rq);
382 return ret; 382 return ret;
@@ -420,9 +420,10 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
420 struct scsi_ioctl_command __user *sic) 420 struct scsi_ioctl_command __user *sic)
421{ 421{
422 struct request *rq; 422 struct request *rq;
423 struct scsi_request *req;
423 int err; 424 int err;
424 unsigned int in_len, out_len, bytes, opcode, cmdlen; 425 unsigned int in_len, out_len, bytes, opcode, cmdlen;
425 char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE]; 426 char *buffer = NULL;
426 427
427 if (!sic) 428 if (!sic)
428 return -EINVAL; 429 return -EINVAL;
@@ -452,7 +453,8 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
452 err = PTR_ERR(rq); 453 err = PTR_ERR(rq);
453 goto error_free_buffer; 454 goto error_free_buffer;
454 } 455 }
455 blk_rq_set_block_pc(rq); 456 req = scsi_req(rq);
457 scsi_req_init(rq);
456 458
457 cmdlen = COMMAND_SIZE(opcode); 459 cmdlen = COMMAND_SIZE(opcode);
458 460
@@ -460,14 +462,14 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
460 * get command and data to send to device, if any 462 * get command and data to send to device, if any
461 */ 463 */
462 err = -EFAULT; 464 err = -EFAULT;
463 rq->cmd_len = cmdlen; 465 req->cmd_len = cmdlen;
464 if (copy_from_user(rq->cmd, sic->data, cmdlen)) 466 if (copy_from_user(req->cmd, sic->data, cmdlen))
465 goto error; 467 goto error;
466 468
467 if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len)) 469 if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
468 goto error; 470 goto error;
469 471
470 err = blk_verify_command(rq->cmd, mode & FMODE_WRITE); 472 err = blk_verify_command(req->cmd, mode & FMODE_WRITE);
471 if (err) 473 if (err)
472 goto error; 474 goto error;
473 475
@@ -503,18 +505,14 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
503 goto error; 505 goto error;
504 } 506 }
505 507
506 memset(sense, 0, sizeof(sense));
507 rq->sense = sense;
508 rq->sense_len = 0;
509
510 blk_execute_rq(q, disk, rq, 0); 508 blk_execute_rq(q, disk, rq, 0);
511 509
512 err = rq->errors & 0xff; /* only 8 bit SCSI status */ 510 err = rq->errors & 0xff; /* only 8 bit SCSI status */
513 if (err) { 511 if (err) {
514 if (rq->sense_len && rq->sense) { 512 if (req->sense_len && req->sense) {
515 bytes = (OMAX_SB_LEN > rq->sense_len) ? 513 bytes = (OMAX_SB_LEN > req->sense_len) ?
516 rq->sense_len : OMAX_SB_LEN; 514 req->sense_len : OMAX_SB_LEN;
517 if (copy_to_user(sic->data, rq->sense, bytes)) 515 if (copy_to_user(sic->data, req->sense, bytes))
518 err = -EFAULT; 516 err = -EFAULT;
519 } 517 }
520 } else { 518 } else {
@@ -542,11 +540,11 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
542 rq = blk_get_request(q, WRITE, __GFP_RECLAIM); 540 rq = blk_get_request(q, WRITE, __GFP_RECLAIM);
543 if (IS_ERR(rq)) 541 if (IS_ERR(rq))
544 return PTR_ERR(rq); 542 return PTR_ERR(rq);
545 blk_rq_set_block_pc(rq); 543 scsi_req_init(rq);
546 rq->timeout = BLK_DEFAULT_SG_TIMEOUT; 544 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
547 rq->cmd[0] = cmd; 545 scsi_req(rq)->cmd[0] = cmd;
548 rq->cmd[4] = data; 546 scsi_req(rq)->cmd[4] = data;
549 rq->cmd_len = 6; 547 scsi_req(rq)->cmd_len = 6;
550 err = blk_execute_rq(q, bd_disk, rq, 0); 548 err = blk_execute_rq(q, bd_disk, rq, 0);
551 blk_put_request(rq); 549 blk_put_request(rq);
552 550
@@ -743,6 +741,18 @@ int scsi_cmd_blk_ioctl(struct block_device *bd, fmode_t mode,
743} 741}
744EXPORT_SYMBOL(scsi_cmd_blk_ioctl); 742EXPORT_SYMBOL(scsi_cmd_blk_ioctl);
745 743
744void scsi_req_init(struct request *rq)
745{
746 struct scsi_request *req = scsi_req(rq);
747
748 rq->cmd_type = REQ_TYPE_BLOCK_PC;
749 memset(req->__cmd, 0, sizeof(req->__cmd));
750 req->cmd = req->__cmd;
751 req->cmd_len = BLK_MAX_CDB;
752 req->sense_len = 0;
753}
754EXPORT_SYMBOL(scsi_req_init);
755
746static int __init blk_scsi_ioctl_init(void) 756static int __init blk_scsi_ioctl_init(void)
747{ 757{
748 blk_set_cmd_filter_defaults(&blk_default_cmd_filter); 758 blk_set_cmd_filter_defaults(&blk_default_cmd_filter);
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 1f863e757ee4..6abd73975f87 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1271,7 +1271,7 @@ static int atapi_drain_needed(struct request *rq)
1271 if (!blk_rq_bytes(rq) || op_is_write(req_op(rq))) 1271 if (!blk_rq_bytes(rq) || op_is_write(req_op(rq)))
1272 return 0; 1272 return 0;
1273 1273
1274 return atapi_cmd_type(rq->cmd[0]) == ATAPI_MISC; 1274 return atapi_cmd_type(scsi_req(rq)->cmd[0]) == ATAPI_MISC;
1275} 1275}
1276 1276
1277static int ata_scsi_dev_config(struct scsi_device *sdev, 1277static int ata_scsi_dev_config(struct scsi_device *sdev,
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index e5c5b8eb14a9..b93bb73b49d2 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -52,6 +52,7 @@
52#include <scsi/scsi.h> 52#include <scsi/scsi.h>
53#include <scsi/sg.h> 53#include <scsi/sg.h>
54#include <scsi/scsi_ioctl.h> 54#include <scsi/scsi_ioctl.h>
55#include <scsi/scsi_request.h>
55#include <linux/cdrom.h> 56#include <linux/cdrom.h>
56#include <linux/scatterlist.h> 57#include <linux/scatterlist.h>
57#include <linux/kthread.h> 58#include <linux/kthread.h>
@@ -1854,7 +1855,7 @@ static void cciss_softirq_done(struct request *rq)
1854 1855
1855 /* set the residual count for pc requests */ 1856 /* set the residual count for pc requests */
1856 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) 1857 if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
1857 rq->resid_len = c->err_info->ResidualCnt; 1858 scsi_req(rq)->resid_len = c->err_info->ResidualCnt;
1858 1859
1859 blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO); 1860 blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);
1860 1861
@@ -1941,9 +1942,16 @@ static void cciss_get_serial_no(ctlr_info_t *h, int logvol,
1941static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk, 1942static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
1942 int drv_index) 1943 int drv_index)
1943{ 1944{
1944 disk->queue = blk_init_queue(do_cciss_request, &h->lock); 1945 disk->queue = blk_alloc_queue(GFP_KERNEL);
1945 if (!disk->queue) 1946 if (!disk->queue)
1946 goto init_queue_failure; 1947 goto init_queue_failure;
1948
1949 disk->queue->cmd_size = sizeof(struct scsi_request);
1950 disk->queue->request_fn = do_cciss_request;
1951 disk->queue->queue_lock = &h->lock;
1952 if (blk_init_allocated_queue(disk->queue) < 0)
1953 goto cleanup_queue;
1954
1947 sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index); 1955 sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index);
1948 disk->major = h->major; 1956 disk->major = h->major;
1949 disk->first_minor = drv_index << NWD_SHIFT; 1957 disk->first_minor = drv_index << NWD_SHIFT;
@@ -3111,15 +3119,7 @@ static inline int evaluate_target_status(ctlr_info_t *h,
3111 return error_value; 3119 return error_value;
3112 } 3120 }
3113 3121
3114 /* SG_IO or similar, copy sense data back */ 3122 scsi_req(cmd->rq)->sense_len = cmd->err_info->SenseLen;
3115 if (cmd->rq->sense) {
3116 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
3117 cmd->rq->sense_len = cmd->err_info->SenseLen;
3118 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
3119 cmd->rq->sense_len);
3120 } else
3121 cmd->rq->sense_len = 0;
3122
3123 return error_value; 3123 return error_value;
3124} 3124}
3125 3125
@@ -3150,7 +3150,6 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
3150 dev_warn(&h->pdev->dev, "cmd %p has" 3150 dev_warn(&h->pdev->dev, "cmd %p has"
3151 " completed with data underrun " 3151 " completed with data underrun "
3152 "reported\n", cmd); 3152 "reported\n", cmd);
3153 cmd->rq->resid_len = cmd->err_info->ResidualCnt;
3154 } 3153 }
3155 break; 3154 break;
3156 case CMD_DATA_OVERRUN: 3155 case CMD_DATA_OVERRUN:
@@ -3426,8 +3425,9 @@ static void do_cciss_request(struct request_queue *q)
3426 c->Request.CDB[14] = c->Request.CDB[15] = 0; 3425 c->Request.CDB[14] = c->Request.CDB[15] = 0;
3427 } 3426 }
3428 } else if (creq->cmd_type == REQ_TYPE_BLOCK_PC) { 3427 } else if (creq->cmd_type == REQ_TYPE_BLOCK_PC) {
3429 c->Request.CDBLen = creq->cmd_len; 3428 c->Request.CDBLen = scsi_req(creq)->cmd_len;
3430 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB); 3429 memcpy(c->Request.CDB, scsi_req(creq)->cmd, BLK_MAX_CDB);
3430 scsi_req(creq)->sense = c->err_info->SenseInfo;
3431 } else { 3431 } else {
3432 dev_warn(&h->pdev->dev, "bad request type %d\n", 3432 dev_warn(&h->pdev->dev, "bad request type %d\n",
3433 creq->cmd_type); 3433 creq->cmd_type);
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 1b94c1ca5c5f..918a92ccd0c0 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -707,7 +707,7 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
707 WRITE : READ, __GFP_RECLAIM); 707 WRITE : READ, __GFP_RECLAIM);
708 if (IS_ERR(rq)) 708 if (IS_ERR(rq))
709 return PTR_ERR(rq); 709 return PTR_ERR(rq);
710 blk_rq_set_block_pc(rq); 710 scsi_req_init(rq);
711 711
712 if (cgc->buflen) { 712 if (cgc->buflen) {
713 ret = blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen, 713 ret = blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen,
@@ -716,8 +716,8 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
716 goto out; 716 goto out;
717 } 717 }
718 718
719 rq->cmd_len = COMMAND_SIZE(cgc->cmd[0]); 719 scsi_req(rq)->cmd_len = COMMAND_SIZE(cgc->cmd[0]);
720 memcpy(rq->cmd, cgc->cmd, CDROM_PACKET_SIZE); 720 memcpy(scsi_req(rq)->cmd, cgc->cmd, CDROM_PACKET_SIZE);
721 721
722 rq->timeout = 60*HZ; 722 rq->timeout = 60*HZ;
723 if (cgc->quiet) 723 if (cgc->quiet)
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 10332c24f961..3027d2efc5d8 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -52,6 +52,7 @@ struct virtio_blk {
52}; 52};
53 53
54struct virtblk_req { 54struct virtblk_req {
55 struct scsi_request sreq; /* for SCSI passthrough */
55 struct request *req; 56 struct request *req;
56 struct virtio_blk_outhdr out_hdr; 57 struct virtio_blk_outhdr out_hdr;
57 struct virtio_scsi_inhdr in_hdr; 58 struct virtio_scsi_inhdr in_hdr;
@@ -91,7 +92,7 @@ static int __virtblk_add_req(struct virtqueue *vq,
91 * inhdr with additional status information. 92 * inhdr with additional status information.
92 */ 93 */
93 if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) { 94 if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) {
94 sg_init_one(&cmd, vbr->req->cmd, vbr->req->cmd_len); 95 sg_init_one(&cmd, vbr->sreq.cmd, vbr->sreq.cmd_len);
95 sgs[num_out++] = &cmd; 96 sgs[num_out++] = &cmd;
96 } 97 }
97 98
@@ -103,7 +104,6 @@ static int __virtblk_add_req(struct virtqueue *vq,
103 } 104 }
104 105
105 if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) { 106 if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) {
106 memcpy(vbr->sense, vbr->req->sense, SCSI_SENSE_BUFFERSIZE);
107 sg_init_one(&sense, vbr->sense, SCSI_SENSE_BUFFERSIZE); 107 sg_init_one(&sense, vbr->sense, SCSI_SENSE_BUFFERSIZE);
108 sgs[num_out + num_in++] = &sense; 108 sgs[num_out + num_in++] = &sense;
109 sg_init_one(&inhdr, &vbr->in_hdr, sizeof(vbr->in_hdr)); 109 sg_init_one(&inhdr, &vbr->in_hdr, sizeof(vbr->in_hdr));
@@ -123,8 +123,10 @@ static inline void virtblk_request_done(struct request *req)
123 int error = virtblk_result(vbr); 123 int error = virtblk_result(vbr);
124 124
125 if (req->cmd_type == REQ_TYPE_BLOCK_PC) { 125 if (req->cmd_type == REQ_TYPE_BLOCK_PC) {
126 req->resid_len = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.residual); 126 scsi_req(req)->resid_len =
127 req->sense_len = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.sense_len); 127 virtio32_to_cpu(vblk->vdev, vbr->in_hdr.residual);
128 vbr->sreq.sense_len =
129 virtio32_to_cpu(vblk->vdev, vbr->in_hdr.sense_len);
128 req->errors = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.errors); 130 req->errors = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.errors);
129 } else if (req->cmd_type == REQ_TYPE_DRV_PRIV) { 131 } else if (req->cmd_type == REQ_TYPE_DRV_PRIV) {
130 req->errors = (error != 0); 132 req->errors = (error != 0);
@@ -538,6 +540,7 @@ static int virtblk_init_request(void *data, struct request *rq,
538 struct virtio_blk *vblk = data; 540 struct virtio_blk *vblk = data;
539 struct virtblk_req *vbr = blk_mq_rq_to_pdu(rq); 541 struct virtblk_req *vbr = blk_mq_rq_to_pdu(rq);
540 542
543 vbr->sreq.sense = vbr->sense;
541 sg_init_table(vbr->sg, vblk->sg_elems); 544 sg_init_table(vbr->sg, vblk->sg_elems);
542 return 0; 545 return 0;
543} 546}
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 59cca72647a6..36f5237a8a69 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -281,8 +281,8 @@
281#include <linux/fcntl.h> 281#include <linux/fcntl.h>
282#include <linux/blkdev.h> 282#include <linux/blkdev.h>
283#include <linux/times.h> 283#include <linux/times.h>
284
285#include <linux/uaccess.h> 284#include <linux/uaccess.h>
285#include <scsi/scsi_request.h>
286 286
287/* used to tell the module to turn on full debugging messages */ 287/* used to tell the module to turn on full debugging messages */
288static bool debug; 288static bool debug;
@@ -2172,6 +2172,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2172{ 2172{
2173 struct request_queue *q = cdi->disk->queue; 2173 struct request_queue *q = cdi->disk->queue;
2174 struct request *rq; 2174 struct request *rq;
2175 struct scsi_request *req;
2175 struct bio *bio; 2176 struct bio *bio;
2176 unsigned int len; 2177 unsigned int len;
2177 int nr, ret = 0; 2178 int nr, ret = 0;
@@ -2195,7 +2196,8 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2195 ret = PTR_ERR(rq); 2196 ret = PTR_ERR(rq);
2196 break; 2197 break;
2197 } 2198 }
2198 blk_rq_set_block_pc(rq); 2199 req = scsi_req(rq);
2200 scsi_req_init(rq);
2199 2201
2200 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL); 2202 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2201 if (ret) { 2203 if (ret) {
@@ -2203,23 +2205,23 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2203 break; 2205 break;
2204 } 2206 }
2205 2207
2206 rq->cmd[0] = GPCMD_READ_CD; 2208 req->cmd[0] = GPCMD_READ_CD;
2207 rq->cmd[1] = 1 << 2; 2209 req->cmd[1] = 1 << 2;
2208 rq->cmd[2] = (lba >> 24) & 0xff; 2210 req->cmd[2] = (lba >> 24) & 0xff;
2209 rq->cmd[3] = (lba >> 16) & 0xff; 2211 req->cmd[3] = (lba >> 16) & 0xff;
2210 rq->cmd[4] = (lba >> 8) & 0xff; 2212 req->cmd[4] = (lba >> 8) & 0xff;
2211 rq->cmd[5] = lba & 0xff; 2213 req->cmd[5] = lba & 0xff;
2212 rq->cmd[6] = (nr >> 16) & 0xff; 2214 req->cmd[6] = (nr >> 16) & 0xff;
2213 rq->cmd[7] = (nr >> 8) & 0xff; 2215 req->cmd[7] = (nr >> 8) & 0xff;
2214 rq->cmd[8] = nr & 0xff; 2216 req->cmd[8] = nr & 0xff;
2215 rq->cmd[9] = 0xf8; 2217 req->cmd[9] = 0xf8;
2216 2218
2217 rq->cmd_len = 12; 2219 req->cmd_len = 12;
2218 rq->timeout = 60 * HZ; 2220 rq->timeout = 60 * HZ;
2219 bio = rq->bio; 2221 bio = rq->bio;
2220 2222
2221 if (blk_execute_rq(q, cdi->disk, rq, 0)) { 2223 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2222 struct request_sense *s = rq->sense; 2224 struct request_sense *s = req->sense;
2223 ret = -EIO; 2225 ret = -EIO;
2224 cdi->last_sense = s->sense_key; 2226 cdi->last_sense = s->sense_key;
2225 } 2227 }
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index f90ea221f7f2..7c826ecbd276 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -93,6 +93,7 @@ int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
93 int error; 93 int error;
94 94
95 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 95 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
96 scsi_req_init(rq);
96 rq->cmd_type = REQ_TYPE_DRV_PRIV; 97 rq->cmd_type = REQ_TYPE_DRV_PRIV;
97 rq->special = (char *)pc; 98 rq->special = (char *)pc;
98 99
@@ -103,9 +104,9 @@ int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
103 goto put_req; 104 goto put_req;
104 } 105 }
105 106
106 memcpy(rq->cmd, pc->c, 12); 107 memcpy(scsi_req(rq)->cmd, pc->c, 12);
107 if (drive->media == ide_tape) 108 if (drive->media == ide_tape)
108 rq->cmd[13] = REQ_IDETAPE_PC1; 109 scsi_req(rq)->cmd[13] = REQ_IDETAPE_PC1;
109 error = blk_execute_rq(drive->queue, disk, rq, 0); 110 error = blk_execute_rq(drive->queue, disk, rq, 0);
110put_req: 111put_req:
111 blk_put_request(rq); 112 blk_put_request(rq);
@@ -171,7 +172,8 @@ EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
171void ide_prep_sense(ide_drive_t *drive, struct request *rq) 172void ide_prep_sense(ide_drive_t *drive, struct request *rq)
172{ 173{
173 struct request_sense *sense = &drive->sense_data; 174 struct request_sense *sense = &drive->sense_data;
174 struct request *sense_rq = &drive->sense_rq; 175 struct request *sense_rq = drive->sense_rq;
176 struct scsi_request *req = scsi_req(sense_rq);
175 unsigned int cmd_len, sense_len; 177 unsigned int cmd_len, sense_len;
176 int err; 178 int err;
177 179
@@ -197,6 +199,7 @@ void ide_prep_sense(ide_drive_t *drive, struct request *rq)
197 memset(sense, 0, sizeof(*sense)); 199 memset(sense, 0, sizeof(*sense));
198 200
199 blk_rq_init(rq->q, sense_rq); 201 blk_rq_init(rq->q, sense_rq);
202 scsi_req_init(sense_rq);
200 203
201 err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len, 204 err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
202 GFP_NOIO); 205 GFP_NOIO);
@@ -208,13 +211,13 @@ void ide_prep_sense(ide_drive_t *drive, struct request *rq)
208 } 211 }
209 212
210 sense_rq->rq_disk = rq->rq_disk; 213 sense_rq->rq_disk = rq->rq_disk;
211 sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
212 sense_rq->cmd[4] = cmd_len;
213 sense_rq->cmd_type = REQ_TYPE_ATA_SENSE; 214 sense_rq->cmd_type = REQ_TYPE_ATA_SENSE;
214 sense_rq->rq_flags |= RQF_PREEMPT; 215 sense_rq->rq_flags |= RQF_PREEMPT;
215 216
217 req->cmd[0] = GPCMD_REQUEST_SENSE;
218 req->cmd[4] = cmd_len;
216 if (drive->media == ide_tape) 219 if (drive->media == ide_tape)
217 sense_rq->cmd[13] = REQ_IDETAPE_PC1; 220 req->cmd[13] = REQ_IDETAPE_PC1;
218 221
219 drive->sense_rq_armed = true; 222 drive->sense_rq_armed = true;
220} 223}
@@ -229,12 +232,12 @@ int ide_queue_sense_rq(ide_drive_t *drive, void *special)
229 return -ENOMEM; 232 return -ENOMEM;
230 } 233 }
231 234
232 drive->sense_rq.special = special; 235 drive->sense_rq->special = special;
233 drive->sense_rq_armed = false; 236 drive->sense_rq_armed = false;
234 237
235 drive->hwif->rq = NULL; 238 drive->hwif->rq = NULL;
236 239
237 elv_add_request(drive->queue, &drive->sense_rq, ELEVATOR_INSERT_FRONT); 240 elv_add_request(drive->queue, drive->sense_rq, ELEVATOR_INSERT_FRONT);
238 return 0; 241 return 0;
239} 242}
240EXPORT_SYMBOL_GPL(ide_queue_sense_rq); 243EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
@@ -247,14 +250,14 @@ EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
247void ide_retry_pc(ide_drive_t *drive) 250void ide_retry_pc(ide_drive_t *drive)
248{ 251{
249 struct request *failed_rq = drive->hwif->rq; 252 struct request *failed_rq = drive->hwif->rq;
250 struct request *sense_rq = &drive->sense_rq; 253 struct request *sense_rq = drive->sense_rq;
251 struct ide_atapi_pc *pc = &drive->request_sense_pc; 254 struct ide_atapi_pc *pc = &drive->request_sense_pc;
252 255
253 (void)ide_read_error(drive); 256 (void)ide_read_error(drive);
254 257
255 /* init pc from sense_rq */ 258 /* init pc from sense_rq */
256 ide_init_pc(pc); 259 ide_init_pc(pc);
257 memcpy(pc->c, sense_rq->cmd, 12); 260 memcpy(pc->c, scsi_req(sense_rq)->cmd, 12);
258 261
259 if (drive->media == ide_tape) 262 if (drive->media == ide_tape)
260 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC; 263 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
@@ -286,7 +289,7 @@ int ide_cd_expiry(ide_drive_t *drive)
286 * commands/drives support that. Let ide_timer_expiry keep polling us 289 * commands/drives support that. Let ide_timer_expiry keep polling us
287 * for these. 290 * for these.
288 */ 291 */
289 switch (rq->cmd[0]) { 292 switch (scsi_req(rq)->cmd[0]) {
290 case GPCMD_BLANK: 293 case GPCMD_BLANK:
291 case GPCMD_FORMAT_UNIT: 294 case GPCMD_FORMAT_UNIT:
292 case GPCMD_RESERVE_RZONE_TRACK: 295 case GPCMD_RESERVE_RZONE_TRACK:
@@ -297,7 +300,7 @@ int ide_cd_expiry(ide_drive_t *drive)
297 default: 300 default:
298 if (!(rq->rq_flags & RQF_QUIET)) 301 if (!(rq->rq_flags & RQF_QUIET))
299 printk(KERN_INFO PFX "cmd 0x%x timed out\n", 302 printk(KERN_INFO PFX "cmd 0x%x timed out\n",
300 rq->cmd[0]); 303 scsi_req(rq)->cmd[0]);
301 wait = 0; 304 wait = 0;
302 break; 305 break;
303 } 306 }
@@ -420,7 +423,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
420 ? "write" : "read"); 423 ? "write" : "read");
421 pc->flags |= PC_FLAG_DMA_ERROR; 424 pc->flags |= PC_FLAG_DMA_ERROR;
422 } else 425 } else
423 rq->resid_len = 0; 426 scsi_req(rq)->resid_len = 0;
424 debug_log("%s: DMA finished\n", drive->name); 427 debug_log("%s: DMA finished\n", drive->name);
425 } 428 }
426 429
@@ -436,7 +439,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
436 local_irq_enable_in_hardirq(); 439 local_irq_enable_in_hardirq();
437 440
438 if (drive->media == ide_tape && 441 if (drive->media == ide_tape &&
439 (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE) 442 (stat & ATA_ERR) && scsi_req(rq)->cmd[0] == REQUEST_SENSE)
440 stat &= ~ATA_ERR; 443 stat &= ~ATA_ERR;
441 444
442 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) { 445 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
@@ -446,7 +449,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
446 if (drive->media != ide_tape) 449 if (drive->media != ide_tape)
447 pc->rq->errors++; 450 pc->rq->errors++;
448 451
449 if (rq->cmd[0] == REQUEST_SENSE) { 452 if (scsi_req(rq)->cmd[0] == REQUEST_SENSE) {
450 printk(KERN_ERR PFX "%s: I/O error in request " 453 printk(KERN_ERR PFX "%s: I/O error in request "
451 "sense command\n", drive->name); 454 "sense command\n", drive->name);
452 return ide_do_reset(drive); 455 return ide_do_reset(drive);
@@ -512,7 +515,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
512 ide_pio_bytes(drive, cmd, write, done); 515 ide_pio_bytes(drive, cmd, write, done);
513 516
514 /* Update transferred byte count */ 517 /* Update transferred byte count */
515 rq->resid_len -= done; 518 scsi_req(rq)->resid_len -= done;
516 519
517 bcount -= done; 520 bcount -= done;
518 521
@@ -520,7 +523,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
520 ide_pad_transfer(drive, write, bcount); 523 ide_pad_transfer(drive, write, bcount);
521 524
522 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n", 525 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
523 rq->cmd[0], done, bcount, rq->resid_len); 526 rq->cmd[0], done, bcount, scsi_req(rq)->resid_len);
524 527
525 /* And set the interrupt handler again */ 528 /* And set the interrupt handler again */
526 ide_set_handler(drive, ide_pc_intr, timeout); 529 ide_set_handler(drive, ide_pc_intr, timeout);
@@ -603,7 +606,7 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
603 606
604 if (dev_is_idecd(drive)) { 607 if (dev_is_idecd(drive)) {
605 /* ATAPI commands get padded out to 12 bytes minimum */ 608 /* ATAPI commands get padded out to 12 bytes minimum */
606 cmd_len = COMMAND_SIZE(rq->cmd[0]); 609 cmd_len = COMMAND_SIZE(scsi_req(rq)->cmd[0]);
607 if (cmd_len < ATAPI_MIN_CDB_BYTES) 610 if (cmd_len < ATAPI_MIN_CDB_BYTES)
608 cmd_len = ATAPI_MIN_CDB_BYTES; 611 cmd_len = ATAPI_MIN_CDB_BYTES;
609 612
@@ -650,7 +653,7 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
650 653
651 /* Send the actual packet */ 654 /* Send the actual packet */
652 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0) 655 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
653 hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len); 656 hwif->tp_ops->output_data(drive, NULL, scsi_req(rq)->cmd, cmd_len);
654 657
655 /* Begin DMA, if necessary */ 658 /* Begin DMA, if necessary */
656 if (dev_is_idecd(drive)) { 659 if (dev_is_idecd(drive)) {
@@ -695,7 +698,7 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
695 bytes, 63 * 1024)); 698 bytes, 63 * 1024));
696 699
697 /* We haven't transferred any data yet */ 700 /* We haven't transferred any data yet */
698 rq->resid_len = bcount; 701 scsi_req(rq)->resid_len = bcount;
699 702
700 if (pc->flags & PC_FLAG_DMA_ERROR) { 703 if (pc->flags & PC_FLAG_DMA_ERROR) {
701 pc->flags &= ~PC_FLAG_DMA_ERROR; 704 pc->flags &= ~PC_FLAG_DMA_ERROR;
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 9cbd217bc0c9..6eb98725e194 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -121,7 +121,7 @@ static int cdrom_log_sense(ide_drive_t *drive, struct request *rq)
121 * don't log START_STOP unit with LoEj set, since we cannot 121 * don't log START_STOP unit with LoEj set, since we cannot
122 * reliably check if drive can auto-close 122 * reliably check if drive can auto-close
123 */ 123 */
124 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24) 124 if (scsi_req(rq)->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
125 break; 125 break;
126 log = 1; 126 log = 1;
127 break; 127 break;
@@ -163,7 +163,7 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
163 * toc has not been recorded yet, it will fail with 05/24/00 (which is a 163 * toc has not been recorded yet, it will fail with 05/24/00 (which is a
164 * confusing error) 164 * confusing error)
165 */ 165 */
166 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP) 166 if (failed_command && scsi_req(failed_command)->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
167 if (sense->sense_key == 0x05 && sense->asc == 0x24) 167 if (sense->sense_key == 0x05 && sense->asc == 0x24)
168 return; 168 return;
169 169
@@ -219,15 +219,12 @@ static void ide_cd_complete_failed_rq(ide_drive_t *drive, struct request *rq)
219 void *sense = bio_data(rq->bio); 219 void *sense = bio_data(rq->bio);
220 220
221 if (failed) { 221 if (failed) {
222 if (failed->sense) { 222 /*
223 /* 223 * Sense is always read into drive->sense_data, copy back to the
224 * Sense is always read into drive->sense_data. 224 * original request.
225 * Copy back if the failed request has its 225 */
226 * sense pointer set. 226 memcpy(scsi_req(failed)->sense, sense, 18);
227 */ 227 scsi_req(failed)->sense_len = scsi_req(rq)->sense_len;
228 memcpy(failed->sense, sense, 18);
229 failed->sense_len = rq->sense_len;
230 }
231 cdrom_analyze_sense_data(drive, failed); 228 cdrom_analyze_sense_data(drive, failed);
232 229
233 if (ide_end_rq(drive, failed, -EIO, blk_rq_bytes(failed))) 230 if (ide_end_rq(drive, failed, -EIO, blk_rq_bytes(failed)))
@@ -338,7 +335,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
338 * 335 *
339 * cdrom_log_sense() knows this! 336 * cdrom_log_sense() knows this!
340 */ 337 */
341 if (rq->cmd[0] == GPCMD_START_STOP_UNIT) 338 if (scsi_req(rq)->cmd[0] == GPCMD_START_STOP_UNIT)
342 break; 339 break;
343 /* fall-through */ 340 /* fall-through */
344 case DATA_PROTECT: 341 case DATA_PROTECT:
@@ -414,7 +411,7 @@ static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct ide_cmd *cmd)
414 * Some of the trailing request sense fields are optional, 411 * Some of the trailing request sense fields are optional,
415 * and some drives don't send them. Sigh. 412 * and some drives don't send them. Sigh.
416 */ 413 */
417 if (rq->cmd[0] == GPCMD_REQUEST_SENSE && 414 if (scsi_req(rq)->cmd[0] == GPCMD_REQUEST_SENSE &&
418 cmd->nleft > 0 && cmd->nleft <= 5) 415 cmd->nleft > 0 && cmd->nleft <= 5)
419 cmd->nleft = 0; 416 cmd->nleft = 0;
420} 417}
@@ -425,12 +422,8 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
425 req_flags_t rq_flags) 422 req_flags_t rq_flags)
426{ 423{
427 struct cdrom_info *info = drive->driver_data; 424 struct cdrom_info *info = drive->driver_data;
428 struct request_sense local_sense;
429 int retries = 10; 425 int retries = 10;
430 req_flags_t flags = 0; 426 bool failed;
431
432 if (!sense)
433 sense = &local_sense;
434 427
435 ide_debug_log(IDE_DBG_PC, "cmd[0]: 0x%x, write: 0x%x, timeout: %d, " 428 ide_debug_log(IDE_DBG_PC, "cmd[0]: 0x%x, write: 0x%x, timeout: %d, "
436 "rq_flags: 0x%x", 429 "rq_flags: 0x%x",
@@ -440,12 +433,12 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
440 do { 433 do {
441 struct request *rq; 434 struct request *rq;
442 int error; 435 int error;
436 bool delay = false;
443 437
444 rq = blk_get_request(drive->queue, write, __GFP_RECLAIM); 438 rq = blk_get_request(drive->queue, write, __GFP_RECLAIM);
445 439 scsi_req_init(rq);
446 memcpy(rq->cmd, cmd, BLK_MAX_CDB); 440 memcpy(scsi_req(rq)->cmd, cmd, BLK_MAX_CDB);
447 rq->cmd_type = REQ_TYPE_ATA_PC; 441 rq->cmd_type = REQ_TYPE_ATA_PC;
448 rq->sense = sense;
449 rq->rq_flags |= rq_flags; 442 rq->rq_flags |= rq_flags;
450 rq->timeout = timeout; 443 rq->timeout = timeout;
451 if (buffer) { 444 if (buffer) {
@@ -460,21 +453,21 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
460 error = blk_execute_rq(drive->queue, info->disk, rq, 0); 453 error = blk_execute_rq(drive->queue, info->disk, rq, 0);
461 454
462 if (buffer) 455 if (buffer)
463 *bufflen = rq->resid_len; 456 *bufflen = scsi_req(rq)->resid_len;
464 457 if (sense)
465 flags = rq->rq_flags; 458 memcpy(sense, scsi_req(rq)->sense, sizeof(*sense));
466 blk_put_request(rq);
467 459
468 /* 460 /*
469 * FIXME: we should probably abort/retry or something in case of 461 * FIXME: we should probably abort/retry or something in case of
470 * failure. 462 * failure.
471 */ 463 */
472 if (flags & RQF_FAILED) { 464 failed = (rq->rq_flags & RQF_FAILED) != 0;
465 if (failed) {
473 /* 466 /*
474 * The request failed. Retry if it was due to a unit 467 * The request failed. Retry if it was due to a unit
475 * attention status (usually means media was changed). 468 * attention status (usually means media was changed).
476 */ 469 */
477 struct request_sense *reqbuf = sense; 470 struct request_sense *reqbuf = scsi_req(rq)->sense;
478 471
479 if (reqbuf->sense_key == UNIT_ATTENTION) 472 if (reqbuf->sense_key == UNIT_ATTENTION)
480 cdrom_saw_media_change(drive); 473 cdrom_saw_media_change(drive);
@@ -485,19 +478,20 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
485 * a disk. Retry, but wait a little to give 478 * a disk. Retry, but wait a little to give
486 * the drive time to complete the load. 479 * the drive time to complete the load.
487 */ 480 */
488 ssleep(2); 481 delay = true;
489 } else { 482 } else {
490 /* otherwise, don't retry */ 483 /* otherwise, don't retry */
491 retries = 0; 484 retries = 0;
492 } 485 }
493 --retries; 486 --retries;
494 } 487 }
495 488 blk_put_request(rq);
496 /* end of retry loop */ 489 if (delay)
497 } while ((flags & RQF_FAILED) && retries >= 0); 490 ssleep(2);
491 } while (failed && retries >= 0);
498 492
499 /* return an error if the command failed */ 493 /* return an error if the command failed */
500 return (flags & RQF_FAILED) ? -EIO : 0; 494 return failed ? -EIO : 0;
501} 495}
502 496
503/* 497/*
@@ -636,7 +630,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
636 len -= blen; 630 len -= blen;
637 631
638 if (sense && write == 0) 632 if (sense && write == 0)
639 rq->sense_len += blen; 633 scsi_req(rq)->sense_len += blen;
640 } 634 }
641 635
642 /* pad, if necessary */ 636 /* pad, if necessary */
@@ -664,7 +658,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
664 658
665out_end: 659out_end:
666 if (rq->cmd_type == REQ_TYPE_BLOCK_PC && rc == 0) { 660 if (rq->cmd_type == REQ_TYPE_BLOCK_PC && rc == 0) {
667 rq->resid_len = 0; 661 scsi_req(rq)->resid_len = 0;
668 blk_end_request_all(rq, 0); 662 blk_end_request_all(rq, 0);
669 hwif->rq = NULL; 663 hwif->rq = NULL;
670 } else { 664 } else {
@@ -685,9 +679,9 @@ out_end:
685 679
686 /* make sure it's fully ended */ 680 /* make sure it's fully ended */
687 if (rq->cmd_type != REQ_TYPE_FS) { 681 if (rq->cmd_type != REQ_TYPE_FS) {
688 rq->resid_len -= cmd->nbytes - cmd->nleft; 682 scsi_req(rq)->resid_len -= cmd->nbytes - cmd->nleft;
689 if (uptodate == 0 && (cmd->tf_flags & IDE_TFLAG_WRITE)) 683 if (uptodate == 0 && (cmd->tf_flags & IDE_TFLAG_WRITE))
690 rq->resid_len += cmd->last_xfer_len; 684 scsi_req(rq)->resid_len += cmd->last_xfer_len;
691 } 685 }
692 686
693 ide_complete_rq(drive, uptodate ? 0 : -EIO, blk_rq_bytes(rq)); 687 ide_complete_rq(drive, uptodate ? 0 : -EIO, blk_rq_bytes(rq));
@@ -1312,28 +1306,29 @@ static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1312 int hard_sect = queue_logical_block_size(q); 1306 int hard_sect = queue_logical_block_size(q);
1313 long block = (long)blk_rq_pos(rq) / (hard_sect >> 9); 1307 long block = (long)blk_rq_pos(rq) / (hard_sect >> 9);
1314 unsigned long blocks = blk_rq_sectors(rq) / (hard_sect >> 9); 1308 unsigned long blocks = blk_rq_sectors(rq) / (hard_sect >> 9);
1309 struct scsi_request *req = scsi_req(rq);
1315 1310
1316 memset(rq->cmd, 0, BLK_MAX_CDB); 1311 memset(req->cmd, 0, BLK_MAX_CDB);
1317 1312
1318 if (rq_data_dir(rq) == READ) 1313 if (rq_data_dir(rq) == READ)
1319 rq->cmd[0] = GPCMD_READ_10; 1314 req->cmd[0] = GPCMD_READ_10;
1320 else 1315 else
1321 rq->cmd[0] = GPCMD_WRITE_10; 1316 req->cmd[0] = GPCMD_WRITE_10;
1322 1317
1323 /* 1318 /*
1324 * fill in lba 1319 * fill in lba
1325 */ 1320 */
1326 rq->cmd[2] = (block >> 24) & 0xff; 1321 req->cmd[2] = (block >> 24) & 0xff;
1327 rq->cmd[3] = (block >> 16) & 0xff; 1322 req->cmd[3] = (block >> 16) & 0xff;
1328 rq->cmd[4] = (block >> 8) & 0xff; 1323 req->cmd[4] = (block >> 8) & 0xff;
1329 rq->cmd[5] = block & 0xff; 1324 req->cmd[5] = block & 0xff;
1330 1325
1331 /* 1326 /*
1332 * and transfer length 1327 * and transfer length
1333 */ 1328 */
1334 rq->cmd[7] = (blocks >> 8) & 0xff; 1329 req->cmd[7] = (blocks >> 8) & 0xff;
1335 rq->cmd[8] = blocks & 0xff; 1330 req->cmd[8] = blocks & 0xff;
1336 rq->cmd_len = 10; 1331 req->cmd_len = 10;
1337 return BLKPREP_OK; 1332 return BLKPREP_OK;
1338} 1333}
1339 1334
@@ -1343,7 +1338,7 @@ static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1343 */ 1338 */
1344static int ide_cdrom_prep_pc(struct request *rq) 1339static int ide_cdrom_prep_pc(struct request *rq)
1345{ 1340{
1346 u8 *c = rq->cmd; 1341 u8 *c = scsi_req(rq)->cmd;
1347 1342
1348 /* transform 6-byte read/write commands to the 10-byte version */ 1343 /* transform 6-byte read/write commands to the 10-byte version */
1349 if (c[0] == READ_6 || c[0] == WRITE_6) { 1344 if (c[0] == READ_6 || c[0] == WRITE_6) {
@@ -1354,7 +1349,7 @@ static int ide_cdrom_prep_pc(struct request *rq)
1354 c[2] = 0; 1349 c[2] = 0;
1355 c[1] &= 0xe0; 1350 c[1] &= 0xe0;
1356 c[0] += (READ_10 - READ_6); 1351 c[0] += (READ_10 - READ_6);
1357 rq->cmd_len = 10; 1352 scsi_req(rq)->cmd_len = 10;
1358 return BLKPREP_OK; 1353 return BLKPREP_OK;
1359 } 1354 }
1360 1355
diff --git a/drivers/ide/ide-cd_ioctl.c b/drivers/ide/ide-cd_ioctl.c
index f085e3a2e1d6..da0aa0153fb1 100644
--- a/drivers/ide/ide-cd_ioctl.c
+++ b/drivers/ide/ide-cd_ioctl.c
@@ -304,6 +304,7 @@ int ide_cdrom_reset(struct cdrom_device_info *cdi)
304 int ret; 304 int ret;
305 305
306 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 306 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
307 scsi_req_init(rq);
307 rq->cmd_type = REQ_TYPE_DRV_PRIV; 308 rq->cmd_type = REQ_TYPE_DRV_PRIV;
308 rq->rq_flags = RQF_QUIET; 309 rq->rq_flags = RQF_QUIET;
309 ret = blk_execute_rq(drive->queue, cd->disk, rq, 0); 310 ret = blk_execute_rq(drive->queue, cd->disk, rq, 0);
diff --git a/drivers/ide/ide-cd_verbose.c b/drivers/ide/ide-cd_verbose.c
index f079ca2f260b..58a6feb74c02 100644
--- a/drivers/ide/ide-cd_verbose.c
+++ b/drivers/ide/ide-cd_verbose.c
@@ -315,12 +315,12 @@ void ide_cd_log_error(const char *name, struct request *failed_command,
315 while (hi > lo) { 315 while (hi > lo) {
316 mid = (lo + hi) / 2; 316 mid = (lo + hi) / 2;
317 if (packet_command_texts[mid].packet_command == 317 if (packet_command_texts[mid].packet_command ==
318 failed_command->cmd[0]) { 318 scsi_req(failed_command)->cmd[0]) {
319 s = packet_command_texts[mid].text; 319 s = packet_command_texts[mid].text;
320 break; 320 break;
321 } 321 }
322 if (packet_command_texts[mid].packet_command > 322 if (packet_command_texts[mid].packet_command >
323 failed_command->cmd[0]) 323 scsi_req(failed_command)->cmd[0])
324 hi = mid; 324 hi = mid;
325 else 325 else
326 lo = mid + 1; 326 lo = mid + 1;
@@ -329,7 +329,7 @@ void ide_cd_log_error(const char *name, struct request *failed_command,
329 printk(KERN_ERR " The failed \"%s\" packet command " 329 printk(KERN_ERR " The failed \"%s\" packet command "
330 "was: \n \"", s); 330 "was: \n \"", s);
331 for (i = 0; i < BLK_MAX_CDB; i++) 331 for (i = 0; i < BLK_MAX_CDB; i++)
332 printk(KERN_CONT "%02x ", failed_command->cmd[i]); 332 printk(KERN_CONT "%02x ", scsi_req(failed_command)->cmd[i]);
333 printk(KERN_CONT "\"\n"); 333 printk(KERN_CONT "\"\n");
334 } 334 }
335 335
diff --git a/drivers/ide/ide-devsets.c b/drivers/ide/ide-devsets.c
index 0dd43b4fcec6..fd56c9dd9bc7 100644
--- a/drivers/ide/ide-devsets.c
+++ b/drivers/ide/ide-devsets.c
@@ -166,10 +166,11 @@ int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
166 return setting->set(drive, arg); 166 return setting->set(drive, arg);
167 167
168 rq = blk_get_request(q, READ, __GFP_RECLAIM); 168 rq = blk_get_request(q, READ, __GFP_RECLAIM);
169 scsi_req_init(rq);
169 rq->cmd_type = REQ_TYPE_DRV_PRIV; 170 rq->cmd_type = REQ_TYPE_DRV_PRIV;
170 rq->cmd_len = 5; 171 scsi_req(rq)->cmd_len = 5;
171 rq->cmd[0] = REQ_DEVSET_EXEC; 172 scsi_req(rq)->cmd[0] = REQ_DEVSET_EXEC;
172 *(int *)&rq->cmd[1] = arg; 173 *(int *)&scsi_req(rq)->cmd[1] = arg;
173 rq->special = setting->set; 174 rq->special = setting->set;
174 175
175 if (blk_execute_rq(q, NULL, rq, 0)) 176 if (blk_execute_rq(q, NULL, rq, 0))
@@ -183,7 +184,7 @@ ide_startstop_t ide_do_devset(ide_drive_t *drive, struct request *rq)
183{ 184{
184 int err, (*setfunc)(ide_drive_t *, int) = rq->special; 185 int err, (*setfunc)(ide_drive_t *, int) = rq->special;
185 186
186 err = setfunc(drive, *(int *)&rq->cmd[1]); 187 err = setfunc(drive, *(int *)&scsi_req(rq)->cmd[1]);
187 if (err) 188 if (err)
188 rq->errors = err; 189 rq->errors = err;
189 ide_complete_rq(drive, err, blk_rq_bytes(rq)); 190 ide_complete_rq(drive, err, blk_rq_bytes(rq));
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 5ceace542b77..3437c5b28599 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -478,6 +478,7 @@ static int set_multcount(ide_drive_t *drive, int arg)
478 return -EBUSY; 478 return -EBUSY;
479 479
480 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 480 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
481 scsi_req_init(rq);
481 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 482 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
482 483
483 drive->mult_req = arg; 484 drive->mult_req = arg;
diff --git a/drivers/ide/ide-eh.c b/drivers/ide/ide-eh.c
index d6da011299f5..35e5b892f9d7 100644
--- a/drivers/ide/ide-eh.c
+++ b/drivers/ide/ide-eh.c
@@ -148,7 +148,7 @@ static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
148 struct request *rq = drive->hwif->rq; 148 struct request *rq = drive->hwif->rq;
149 149
150 if (rq && rq->cmd_type == REQ_TYPE_DRV_PRIV && 150 if (rq && rq->cmd_type == REQ_TYPE_DRV_PRIV &&
151 rq->cmd[0] == REQ_DRIVE_RESET) { 151 scsi_req(rq)->cmd[0] == REQ_DRIVE_RESET) {
152 if (err <= 0 && rq->errors == 0) 152 if (err <= 0 && rq->errors == 0)
153 rq->errors = -EIO; 153 rq->errors = -EIO;
154 ide_complete_rq(drive, err ? err : 0, blk_rq_bytes(rq)); 154 ide_complete_rq(drive, err ? err : 0, blk_rq_bytes(rq));
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index f079d8d1d856..3bd678ad3519 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -203,7 +203,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
203 put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]); 203 put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]);
204 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]); 204 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]);
205 205
206 memcpy(rq->cmd, pc->c, 12); 206 memcpy(scsi_req(rq)->cmd, pc->c, 12);
207 207
208 pc->rq = rq; 208 pc->rq = rq;
209 if (cmd == WRITE) 209 if (cmd == WRITE)
@@ -216,7 +216,7 @@ static void idefloppy_blockpc_cmd(struct ide_disk_obj *floppy,
216 struct ide_atapi_pc *pc, struct request *rq) 216 struct ide_atapi_pc *pc, struct request *rq)
217{ 217{
218 ide_init_pc(pc); 218 ide_init_pc(pc);
219 memcpy(pc->c, rq->cmd, sizeof(pc->c)); 219 memcpy(pc->c, scsi_req(rq)->cmd, sizeof(pc->c));
220 pc->rq = rq; 220 pc->rq = rq;
221 if (blk_rq_bytes(rq)) { 221 if (blk_rq_bytes(rq)) {
222 pc->flags |= PC_FLAG_DMA_OK; 222 pc->flags |= PC_FLAG_DMA_OK;
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 201e43fcbc94..3378503afed4 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -279,7 +279,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
279 279
280static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 280static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq)
281{ 281{
282 u8 cmd = rq->cmd[0]; 282 u8 cmd = scsi_req(rq)->cmd[0];
283 283
284 switch (cmd) { 284 switch (cmd) {
285 case REQ_PARK_HEADS: 285 case REQ_PARK_HEADS:
@@ -545,6 +545,7 @@ repeat:
545 goto plug_device; 545 goto plug_device;
546 } 546 }
547 547
548 scsi_req(rq)->resid_len = blk_rq_bytes(rq);
548 hwif->rq = rq; 549 hwif->rq = rq;
549 550
550 spin_unlock_irq(&hwif->lock); 551 spin_unlock_irq(&hwif->lock);
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index d05db2469209..a5d22c6e956a 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -126,6 +126,7 @@ static int ide_cmd_ioctl(ide_drive_t *drive, unsigned long arg)
126 struct request *rq; 126 struct request *rq;
127 127
128 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 128 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
129 scsi_req_init(rq);
129 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 130 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
130 err = blk_execute_rq(drive->queue, NULL, rq, 0); 131 err = blk_execute_rq(drive->queue, NULL, rq, 0);
131 blk_put_request(rq); 132 blk_put_request(rq);
@@ -222,9 +223,10 @@ static int generic_drive_reset(ide_drive_t *drive)
222 int ret = 0; 223 int ret = 0;
223 224
224 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 225 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
226 scsi_req_init(rq);
225 rq->cmd_type = REQ_TYPE_DRV_PRIV; 227 rq->cmd_type = REQ_TYPE_DRV_PRIV;
226 rq->cmd_len = 1; 228 scsi_req(rq)->cmd_len = 1;
227 rq->cmd[0] = REQ_DRIVE_RESET; 229 scsi_req(rq)->cmd[0] = REQ_DRIVE_RESET;
228 if (blk_execute_rq(drive->queue, NULL, rq, 1)) 230 if (blk_execute_rq(drive->queue, NULL, rq, 1))
229 ret = rq->errors; 231 ret = rq->errors;
230 blk_put_request(rq); 232 blk_put_request(rq);
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index 2d7dca56dd24..c37604a75097 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -32,8 +32,9 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
32 spin_unlock_irq(&hwif->lock); 32 spin_unlock_irq(&hwif->lock);
33 33
34 rq = blk_get_request(q, READ, __GFP_RECLAIM); 34 rq = blk_get_request(q, READ, __GFP_RECLAIM);
35 rq->cmd[0] = REQ_PARK_HEADS; 35 scsi_req_init(rq);
36 rq->cmd_len = 1; 36 scsi_req(rq)->cmd[0] = REQ_PARK_HEADS;
37 scsi_req(rq)->cmd_len = 1;
37 rq->cmd_type = REQ_TYPE_DRV_PRIV; 38 rq->cmd_type = REQ_TYPE_DRV_PRIV;
38 rq->special = &timeout; 39 rq->special = &timeout;
39 rc = blk_execute_rq(q, NULL, rq, 1); 40 rc = blk_execute_rq(q, NULL, rq, 1);
@@ -46,11 +47,12 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
46 * timeout has expired, so power management will be reenabled. 47 * timeout has expired, so power management will be reenabled.
47 */ 48 */
48 rq = blk_get_request(q, READ, GFP_NOWAIT); 49 rq = blk_get_request(q, READ, GFP_NOWAIT);
50 scsi_req_init(rq);
49 if (IS_ERR(rq)) 51 if (IS_ERR(rq))
50 goto out; 52 goto out;
51 53
52 rq->cmd[0] = REQ_UNPARK_HEADS; 54 scsi_req(rq)->cmd[0] = REQ_UNPARK_HEADS;
53 rq->cmd_len = 1; 55 scsi_req(rq)->cmd_len = 1;
54 rq->cmd_type = REQ_TYPE_DRV_PRIV; 56 rq->cmd_type = REQ_TYPE_DRV_PRIV;
55 elv_add_request(q, rq, ELEVATOR_INSERT_FRONT); 57 elv_add_request(q, rq, ELEVATOR_INSERT_FRONT);
56 58
@@ -64,7 +66,7 @@ ide_startstop_t ide_do_park_unpark(ide_drive_t *drive, struct request *rq)
64 struct ide_taskfile *tf = &cmd.tf; 66 struct ide_taskfile *tf = &cmd.tf;
65 67
66 memset(&cmd, 0, sizeof(cmd)); 68 memset(&cmd, 0, sizeof(cmd));
67 if (rq->cmd[0] == REQ_PARK_HEADS) { 69 if (scsi_req(rq)->cmd[0] == REQ_PARK_HEADS) {
68 drive->sleep = *(unsigned long *)rq->special; 70 drive->sleep = *(unsigned long *)rq->special;
69 drive->dev_flags |= IDE_DFLAG_SLEEPING; 71 drive->dev_flags |= IDE_DFLAG_SLEEPING;
70 tf->command = ATA_CMD_IDLEIMMEDIATE; 72 tf->command = ATA_CMD_IDLEIMMEDIATE;
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index a015acdffb39..f6767aba7cfb 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -19,6 +19,7 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
19 19
20 memset(&rqpm, 0, sizeof(rqpm)); 20 memset(&rqpm, 0, sizeof(rqpm));
21 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 21 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
22 scsi_req_init(rq);
22 rq->cmd_type = REQ_TYPE_ATA_PM_SUSPEND; 23 rq->cmd_type = REQ_TYPE_ATA_PM_SUSPEND;
23 rq->special = &rqpm; 24 rq->special = &rqpm;
24 rqpm.pm_step = IDE_PM_START_SUSPEND; 25 rqpm.pm_step = IDE_PM_START_SUSPEND;
@@ -89,6 +90,7 @@ int generic_ide_resume(struct device *dev)
89 90
90 memset(&rqpm, 0, sizeof(rqpm)); 91 memset(&rqpm, 0, sizeof(rqpm));
91 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 92 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
93 scsi_req_init(rq);
92 rq->cmd_type = REQ_TYPE_ATA_PM_RESUME; 94 rq->cmd_type = REQ_TYPE_ATA_PM_RESUME;
93 rq->rq_flags |= RQF_PREEMPT; 95 rq->rq_flags |= RQF_PREEMPT;
94 rq->special = &rqpm; 96 rq->special = &rqpm;
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 330e319419e6..a74ae8df4bb8 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -741,6 +741,14 @@ static void ide_port_tune_devices(ide_hwif_t *hwif)
741 } 741 }
742} 742}
743 743
744static int ide_init_rq(struct request_queue *q, struct request *rq, gfp_t gfp)
745{
746 struct ide_request *req = blk_mq_rq_to_pdu(rq);
747
748 req->sreq.sense = req->sense;
749 return 0;
750}
751
744/* 752/*
745 * init request queue 753 * init request queue
746 */ 754 */
@@ -758,11 +766,18 @@ static int ide_init_queue(ide_drive_t *drive)
758 * limits and LBA48 we could raise it but as yet 766 * limits and LBA48 we could raise it but as yet
759 * do not. 767 * do not.
760 */ 768 */
761 769 q = blk_alloc_queue_node(GFP_KERNEL, hwif_to_node(hwif));
762 q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
763 if (!q) 770 if (!q)
764 return 1; 771 return 1;
765 772
773 q->request_fn = do_ide_request;
774 q->init_rq_fn = ide_init_rq;
775 q->cmd_size = sizeof(struct ide_request);
776 if (blk_init_allocated_queue(q) < 0) {
777 blk_cleanup_queue(q);
778 return 1;
779 }
780
766 q->queuedata = drive; 781 q->queuedata = drive;
767 blk_queue_segment_boundary(q, 0xffff); 782 blk_queue_segment_boundary(q, 0xffff);
768 783
@@ -1131,10 +1146,12 @@ static void ide_port_init_devices_data(ide_hwif_t *hwif)
1131 ide_port_for_each_dev(i, drive, hwif) { 1146 ide_port_for_each_dev(i, drive, hwif) {
1132 u8 j = (hwif->index * MAX_DRIVES) + i; 1147 u8 j = (hwif->index * MAX_DRIVES) + i;
1133 u16 *saved_id = drive->id; 1148 u16 *saved_id = drive->id;
1149 struct request *saved_sense_rq = drive->sense_rq;
1134 1150
1135 memset(drive, 0, sizeof(*drive)); 1151 memset(drive, 0, sizeof(*drive));
1136 memset(saved_id, 0, SECTOR_SIZE); 1152 memset(saved_id, 0, SECTOR_SIZE);
1137 drive->id = saved_id; 1153 drive->id = saved_id;
1154 drive->sense_rq = saved_sense_rq;
1138 1155
1139 drive->media = ide_disk; 1156 drive->media = ide_disk;
1140 drive->select = (i << 4) | ATA_DEVICE_OBS; 1157 drive->select = (i << 4) | ATA_DEVICE_OBS;
@@ -1241,6 +1258,7 @@ static void ide_port_free_devices(ide_hwif_t *hwif)
1241 int i; 1258 int i;
1242 1259
1243 ide_port_for_each_dev(i, drive, hwif) { 1260 ide_port_for_each_dev(i, drive, hwif) {
1261 kfree(drive->sense_rq);
1244 kfree(drive->id); 1262 kfree(drive->id);
1245 kfree(drive); 1263 kfree(drive);
1246 } 1264 }
@@ -1248,11 +1266,10 @@ static void ide_port_free_devices(ide_hwif_t *hwif)
1248 1266
1249static int ide_port_alloc_devices(ide_hwif_t *hwif, int node) 1267static int ide_port_alloc_devices(ide_hwif_t *hwif, int node)
1250{ 1268{
1269 ide_drive_t *drive;
1251 int i; 1270 int i;
1252 1271
1253 for (i = 0; i < MAX_DRIVES; i++) { 1272 for (i = 0; i < MAX_DRIVES; i++) {
1254 ide_drive_t *drive;
1255
1256 drive = kzalloc_node(sizeof(*drive), GFP_KERNEL, node); 1273 drive = kzalloc_node(sizeof(*drive), GFP_KERNEL, node);
1257 if (drive == NULL) 1274 if (drive == NULL)
1258 goto out_nomem; 1275 goto out_nomem;
@@ -1267,12 +1284,21 @@ static int ide_port_alloc_devices(ide_hwif_t *hwif, int node)
1267 */ 1284 */
1268 drive->id = kzalloc_node(SECTOR_SIZE, GFP_KERNEL, node); 1285 drive->id = kzalloc_node(SECTOR_SIZE, GFP_KERNEL, node);
1269 if (drive->id == NULL) 1286 if (drive->id == NULL)
1270 goto out_nomem; 1287 goto out_free_drive;
1288
1289 drive->sense_rq = kmalloc(sizeof(struct request) +
1290 sizeof(struct ide_request), GFP_KERNEL);
1291 if (!drive->sense_rq)
1292 goto out_free_id;
1271 1293
1272 hwif->devices[i] = drive; 1294 hwif->devices[i] = drive;
1273 } 1295 }
1274 return 0; 1296 return 0;
1275 1297
1298out_free_id:
1299 kfree(drive->id);
1300out_free_drive:
1301 kfree(drive);
1276out_nomem: 1302out_nomem:
1277 ide_port_free_devices(hwif); 1303 ide_port_free_devices(hwif);
1278 return -ENOMEM; 1304 return -ENOMEM;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 9ecf4e35adcd..f6bc1e2bb035 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -282,7 +282,7 @@ static void idetape_analyze_error(ide_drive_t *drive)
282 282
283 /* correct remaining bytes to transfer */ 283 /* correct remaining bytes to transfer */
284 if (pc->flags & PC_FLAG_DMA_ERROR) 284 if (pc->flags & PC_FLAG_DMA_ERROR)
285 rq->resid_len = tape->blk_size * get_unaligned_be32(&sense[3]); 285 scsi_req(rq)->resid_len = tape->blk_size * get_unaligned_be32(&sense[3]);
286 286
287 /* 287 /*
288 * If error was the result of a zero-length read or write command, 288 * If error was the result of a zero-length read or write command,
@@ -316,7 +316,7 @@ static void idetape_analyze_error(ide_drive_t *drive)
316 pc->flags |= PC_FLAG_ABORT; 316 pc->flags |= PC_FLAG_ABORT;
317 } 317 }
318 if (!(pc->flags & PC_FLAG_ABORT) && 318 if (!(pc->flags & PC_FLAG_ABORT) &&
319 (blk_rq_bytes(rq) - rq->resid_len)) 319 (blk_rq_bytes(rq) - scsi_req(rq)->resid_len))
320 pc->retries = IDETAPE_MAX_PC_RETRIES + 1; 320 pc->retries = IDETAPE_MAX_PC_RETRIES + 1;
321 } 321 }
322} 322}
@@ -348,7 +348,7 @@ static int ide_tape_callback(ide_drive_t *drive, int dsc)
348 "itself - Aborting request!\n"); 348 "itself - Aborting request!\n");
349 } else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) { 349 } else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
350 unsigned int blocks = 350 unsigned int blocks =
351 (blk_rq_bytes(rq) - rq->resid_len) / tape->blk_size; 351 (blk_rq_bytes(rq) - scsi_req(rq)->resid_len) / tape->blk_size;
352 352
353 tape->avg_size += blocks * tape->blk_size; 353 tape->avg_size += blocks * tape->blk_size;
354 354
@@ -560,7 +560,7 @@ static void ide_tape_create_rw_cmd(idetape_tape_t *tape,
560 pc->flags |= PC_FLAG_WRITING; 560 pc->flags |= PC_FLAG_WRITING;
561 } 561 }
562 562
563 memcpy(rq->cmd, pc->c, 12); 563 memcpy(scsi_req(rq)->cmd, pc->c, 12);
564} 564}
565 565
566static ide_startstop_t idetape_do_request(ide_drive_t *drive, 566static ide_startstop_t idetape_do_request(ide_drive_t *drive,
@@ -570,10 +570,11 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
570 idetape_tape_t *tape = drive->driver_data; 570 idetape_tape_t *tape = drive->driver_data;
571 struct ide_atapi_pc *pc = NULL; 571 struct ide_atapi_pc *pc = NULL;
572 struct ide_cmd cmd; 572 struct ide_cmd cmd;
573 struct scsi_request *req = scsi_req(rq);
573 u8 stat; 574 u8 stat;
574 575
575 ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, sector: %llu, nr_sectors: %u", 576 ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, sector: %llu, nr_sectors: %u",
576 rq->cmd[0], (unsigned long long)blk_rq_pos(rq), 577 req->cmd[0], (unsigned long long)blk_rq_pos(rq),
577 blk_rq_sectors(rq)); 578 blk_rq_sectors(rq));
578 579
579 BUG_ON(!(rq->cmd_type == REQ_TYPE_DRV_PRIV || 580 BUG_ON(!(rq->cmd_type == REQ_TYPE_DRV_PRIV ||
@@ -592,7 +593,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
592 stat = hwif->tp_ops->read_status(hwif); 593 stat = hwif->tp_ops->read_status(hwif);
593 594
594 if ((drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) == 0 && 595 if ((drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) == 0 &&
595 (rq->cmd[13] & REQ_IDETAPE_PC2) == 0) 596 (req->cmd[13] & REQ_IDETAPE_PC2) == 0)
596 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC; 597 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
597 598
598 if (drive->dev_flags & IDE_DFLAG_POST_RESET) { 599 if (drive->dev_flags & IDE_DFLAG_POST_RESET) {
@@ -609,7 +610,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
609 } else if (time_after(jiffies, tape->dsc_timeout)) { 610 } else if (time_after(jiffies, tape->dsc_timeout)) {
610 printk(KERN_ERR "ide-tape: %s: DSC timeout\n", 611 printk(KERN_ERR "ide-tape: %s: DSC timeout\n",
611 tape->name); 612 tape->name);
612 if (rq->cmd[13] & REQ_IDETAPE_PC2) { 613 if (req->cmd[13] & REQ_IDETAPE_PC2) {
613 idetape_media_access_finished(drive); 614 idetape_media_access_finished(drive);
614 return ide_stopped; 615 return ide_stopped;
615 } else { 616 } else {
@@ -626,23 +627,23 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
626 tape->postponed_rq = false; 627 tape->postponed_rq = false;
627 } 628 }
628 629
629 if (rq->cmd[13] & REQ_IDETAPE_READ) { 630 if (req->cmd[13] & REQ_IDETAPE_READ) {
630 pc = &tape->queued_pc; 631 pc = &tape->queued_pc;
631 ide_tape_create_rw_cmd(tape, pc, rq, READ_6); 632 ide_tape_create_rw_cmd(tape, pc, rq, READ_6);
632 goto out; 633 goto out;
633 } 634 }
634 if (rq->cmd[13] & REQ_IDETAPE_WRITE) { 635 if (req->cmd[13] & REQ_IDETAPE_WRITE) {
635 pc = &tape->queued_pc; 636 pc = &tape->queued_pc;
636 ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6); 637 ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6);
637 goto out; 638 goto out;
638 } 639 }
639 if (rq->cmd[13] & REQ_IDETAPE_PC1) { 640 if (req->cmd[13] & REQ_IDETAPE_PC1) {
640 pc = (struct ide_atapi_pc *)rq->special; 641 pc = (struct ide_atapi_pc *)rq->special;
641 rq->cmd[13] &= ~(REQ_IDETAPE_PC1); 642 req->cmd[13] &= ~(REQ_IDETAPE_PC1);
642 rq->cmd[13] |= REQ_IDETAPE_PC2; 643 req->cmd[13] |= REQ_IDETAPE_PC2;
643 goto out; 644 goto out;
644 } 645 }
645 if (rq->cmd[13] & REQ_IDETAPE_PC2) { 646 if (req->cmd[13] & REQ_IDETAPE_PC2) {
646 idetape_media_access_finished(drive); 647 idetape_media_access_finished(drive);
647 return ide_stopped; 648 return ide_stopped;
648 } 649 }
@@ -853,8 +854,9 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
853 BUG_ON(size < 0 || size % tape->blk_size); 854 BUG_ON(size < 0 || size % tape->blk_size);
854 855
855 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM); 856 rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
857 scsi_req_init(rq);
856 rq->cmd_type = REQ_TYPE_DRV_PRIV; 858 rq->cmd_type = REQ_TYPE_DRV_PRIV;
857 rq->cmd[13] = cmd; 859 scsi_req(rq)->cmd[13] = cmd;
858 rq->rq_disk = tape->disk; 860 rq->rq_disk = tape->disk;
859 rq->__sector = tape->first_frame; 861 rq->__sector = tape->first_frame;
860 862
@@ -868,7 +870,7 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
868 blk_execute_rq(drive->queue, tape->disk, rq, 0); 870 blk_execute_rq(drive->queue, tape->disk, rq, 0);
869 871
870 /* calculate the number of transferred bytes and update buffer state */ 872 /* calculate the number of transferred bytes and update buffer state */
871 size -= rq->resid_len; 873 size -= scsi_req(rq)->resid_len;
872 tape->cur = tape->buf; 874 tape->cur = tape->buf;
873 if (cmd == REQ_IDETAPE_READ) 875 if (cmd == REQ_IDETAPE_READ)
874 tape->valid = size; 876 tape->valid = size;
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index a716693417a3..a393e13b8007 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -431,6 +431,7 @@ int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
431 int rw = !(cmd->tf_flags & IDE_TFLAG_WRITE) ? READ : WRITE; 431 int rw = !(cmd->tf_flags & IDE_TFLAG_WRITE) ? READ : WRITE;
432 432
433 rq = blk_get_request(drive->queue, rw, __GFP_RECLAIM); 433 rq = blk_get_request(drive->queue, rw, __GFP_RECLAIM);
434 scsi_req_init(rq);
434 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 435 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
435 436
436 /* 437 /*
diff --git a/drivers/ide/sis5513.c b/drivers/ide/sis5513.c
index 247853ea1368..c3062b53056f 100644
--- a/drivers/ide/sis5513.c
+++ b/drivers/ide/sis5513.c
@@ -54,7 +54,7 @@
54#define DRV_NAME "sis5513" 54#define DRV_NAME "sis5513"
55 55
56/* registers layout and init values are chipset family dependent */ 56/* registers layout and init values are chipset family dependent */
57 57#undef ATA_16
58#define ATA_16 0x01 58#define ATA_16 0x01
59#define ATA_33 0x02 59#define ATA_33 0x02
60#define ATA_66 0x03 60#define ATA_66 0x03
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 7ee1667acde4..b8c4b2ba7519 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -2320,10 +2320,10 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
2320 SmpPassthroughReply_t *smprep; 2320 SmpPassthroughReply_t *smprep;
2321 2321
2322 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply; 2322 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2323 memcpy(req->sense, smprep, sizeof(*smprep)); 2323 memcpy(scsi_req(req)->sense, smprep, sizeof(*smprep));
2324 req->sense_len = sizeof(*smprep); 2324 scsi_req(req)->sense_len = sizeof(*smprep);
2325 req->resid_len = 0; 2325 scsi_req(req)->resid_len = 0;
2326 rsp->resid_len -= smprep->ResponseDataLength; 2326 scsi_req(rsp)->resid_len -= smprep->ResponseDataLength;
2327 } else { 2327 } else {
2328 printk(MYIOC_s_ERR_FMT 2328 printk(MYIOC_s_ERR_FMT
2329 "%s: smp passthru reply failed to be returned\n", 2329 "%s: smp passthru reply failed to be returned\n",
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 919736a74ffa..aa76f36abe03 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -2095,7 +2095,7 @@ int fc_lport_bsg_request(struct bsg_job *job)
2095 2095
2096 bsg_reply->reply_payload_rcv_len = 0; 2096 bsg_reply->reply_payload_rcv_len = 0;
2097 if (rsp) 2097 if (rsp)
2098 rsp->resid_len = job->reply_payload.payload_len; 2098 scsi_req(rsp)->resid_len = job->reply_payload.payload_len;
2099 2099
2100 mutex_lock(&lport->lp_mutex); 2100 mutex_lock(&lport->lp_mutex);
2101 2101
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 022bb6e10d98..570b2cb2da43 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -2174,12 +2174,12 @@ int sas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
2174 bio_data(rsp->bio), blk_rq_bytes(rsp)); 2174 bio_data(rsp->bio), blk_rq_bytes(rsp));
2175 if (ret > 0) { 2175 if (ret > 0) {
2176 /* positive number is the untransferred residual */ 2176 /* positive number is the untransferred residual */
2177 rsp->resid_len = ret; 2177 scsi_req(rsp)->resid_len = ret;
2178 req->resid_len = 0; 2178 scsi_req(req)->resid_len = 0;
2179 ret = 0; 2179 ret = 0;
2180 } else if (ret == 0) { 2180 } else if (ret == 0) {
2181 rsp->resid_len = 0; 2181 scsi_req(rsp)->resid_len = 0;
2182 req->resid_len = 0; 2182 scsi_req(req)->resid_len = 0;
2183 } 2183 }
2184 2184
2185 return ret; 2185 return ret;
diff --git a/drivers/scsi/libsas/sas_host_smp.c b/drivers/scsi/libsas/sas_host_smp.c
index d24792575169..45cbbc44f4d7 100644
--- a/drivers/scsi/libsas/sas_host_smp.c
+++ b/drivers/scsi/libsas/sas_host_smp.c
@@ -274,15 +274,15 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
274 274
275 switch (req_data[1]) { 275 switch (req_data[1]) {
276 case SMP_REPORT_GENERAL: 276 case SMP_REPORT_GENERAL:
277 req->resid_len -= 8; 277 scsi_req(req)->resid_len -= 8;
278 rsp->resid_len -= 32; 278 scsi_req(rsp)->resid_len -= 32;
279 resp_data[2] = SMP_RESP_FUNC_ACC; 279 resp_data[2] = SMP_RESP_FUNC_ACC;
280 resp_data[9] = sas_ha->num_phys; 280 resp_data[9] = sas_ha->num_phys;
281 break; 281 break;
282 282
283 case SMP_REPORT_MANUF_INFO: 283 case SMP_REPORT_MANUF_INFO:
284 req->resid_len -= 8; 284 scsi_req(req)->resid_len -= 8;
285 rsp->resid_len -= 64; 285 scsi_req(rsp)->resid_len -= 64;
286 resp_data[2] = SMP_RESP_FUNC_ACC; 286 resp_data[2] = SMP_RESP_FUNC_ACC;
287 memcpy(resp_data + 12, shost->hostt->name, 287 memcpy(resp_data + 12, shost->hostt->name,
288 SAS_EXPANDER_VENDOR_ID_LEN); 288 SAS_EXPANDER_VENDOR_ID_LEN);
@@ -295,13 +295,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
295 break; 295 break;
296 296
297 case SMP_DISCOVER: 297 case SMP_DISCOVER:
298 req->resid_len -= 16; 298 scsi_req(req)->resid_len -= 16;
299 if ((int)req->resid_len < 0) { 299 if ((int)scsi_req(req)->resid_len < 0) {
300 req->resid_len = 0; 300 scsi_req(req)->resid_len = 0;
301 error = -EINVAL; 301 error = -EINVAL;
302 goto out; 302 goto out;
303 } 303 }
304 rsp->resid_len -= 56; 304 scsi_req(rsp)->resid_len -= 56;
305 sas_host_smp_discover(sas_ha, resp_data, req_data[9]); 305 sas_host_smp_discover(sas_ha, resp_data, req_data[9]);
306 break; 306 break;
307 307
@@ -311,13 +311,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
311 break; 311 break;
312 312
313 case SMP_REPORT_PHY_SATA: 313 case SMP_REPORT_PHY_SATA:
314 req->resid_len -= 16; 314 scsi_req(req)->resid_len -= 16;
315 if ((int)req->resid_len < 0) { 315 if ((int)scsi_req(req)->resid_len < 0) {
316 req->resid_len = 0; 316 scsi_req(req)->resid_len = 0;
317 error = -EINVAL; 317 error = -EINVAL;
318 goto out; 318 goto out;
319 } 319 }
320 rsp->resid_len -= 60; 320 scsi_req(rsp)->resid_len -= 60;
321 sas_report_phy_sata(sas_ha, resp_data, req_data[9]); 321 sas_report_phy_sata(sas_ha, resp_data, req_data[9]);
322 break; 322 break;
323 323
@@ -331,15 +331,15 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
331 int to_write = req_data[4]; 331 int to_write = req_data[4];
332 332
333 if (blk_rq_bytes(req) < base_frame_size + to_write * 4 || 333 if (blk_rq_bytes(req) < base_frame_size + to_write * 4 ||
334 req->resid_len < base_frame_size + to_write * 4) { 334 scsi_req(req)->resid_len < base_frame_size + to_write * 4) {
335 resp_data[2] = SMP_RESP_INV_FRM_LEN; 335 resp_data[2] = SMP_RESP_INV_FRM_LEN;
336 break; 336 break;
337 } 337 }
338 338
339 to_write = sas_host_smp_write_gpio(sas_ha, resp_data, req_data[2], 339 to_write = sas_host_smp_write_gpio(sas_ha, resp_data, req_data[2],
340 req_data[3], to_write, &req_data[8]); 340 req_data[3], to_write, &req_data[8]);
341 req->resid_len -= base_frame_size + to_write * 4; 341 scsi_req(req)->resid_len -= base_frame_size + to_write * 4;
342 rsp->resid_len -= 8; 342 scsi_req(rsp)->resid_len -= 8;
343 break; 343 break;
344 } 344 }
345 345
@@ -348,13 +348,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
348 break; 348 break;
349 349
350 case SMP_PHY_CONTROL: 350 case SMP_PHY_CONTROL:
351 req->resid_len -= 44; 351 scsi_req(req)->resid_len -= 44;
352 if ((int)req->resid_len < 0) { 352 if ((int)scsi_req(req)->resid_len < 0) {
353 req->resid_len = 0; 353 scsi_req(req)->resid_len = 0;
354 error = -EINVAL; 354 error = -EINVAL;
355 goto out; 355 goto out;
356 } 356 }
357 rsp->resid_len -= 8; 357 scsi_req(rsp)->resid_len -= 8;
358 sas_phy_control(sas_ha, req_data[9], req_data[10], 358 sas_phy_control(sas_ha, req_data[9], req_data[10],
359 req_data[32] >> 4, req_data[33] >> 4, 359 req_data[32] >> 4, req_data[33] >> 4,
360 resp_data); 360 resp_data);
diff --git a/drivers/scsi/mpt3sas/mpt3sas_transport.c b/drivers/scsi/mpt3sas/mpt3sas_transport.c
index 7f1d5785bc30..e7a7a704a315 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_transport.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_transport.c
@@ -2057,10 +2057,10 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
2057 ioc->name, __func__, 2057 ioc->name, __func__,
2058 le16_to_cpu(mpi_reply->ResponseDataLength))); 2058 le16_to_cpu(mpi_reply->ResponseDataLength)));
2059 2059
2060 memcpy(req->sense, mpi_reply, sizeof(*mpi_reply)); 2060 memcpy(scsi_req(req)->sense, mpi_reply, sizeof(*mpi_reply));
2061 req->sense_len = sizeof(*mpi_reply); 2061 scsi_req(req)->sense_len = sizeof(*mpi_reply);
2062 req->resid_len = 0; 2062 scsi_req(req)->resid_len = 0;
2063 rsp->resid_len -= 2063 scsi_req(rsp)->resid_len -=
2064 le16_to_cpu(mpi_reply->ResponseDataLength); 2064 le16_to_cpu(mpi_reply->ResponseDataLength);
2065 2065
2066 /* check if the resp needs to be copied from the allocated 2066 /* check if the resp needs to be copied from the allocated
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index ef99f62831fb..fcb040eebf47 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -48,6 +48,7 @@
48#include <scsi/osd_sense.h> 48#include <scsi/osd_sense.h>
49 49
50#include <scsi/scsi_device.h> 50#include <scsi/scsi_device.h>
51#include <scsi/scsi_request.h>
51 52
52#include "osd_debug.h" 53#include "osd_debug.h"
53 54
@@ -477,11 +478,13 @@ static void _set_error_resid(struct osd_request *or, struct request *req,
477{ 478{
478 or->async_error = error; 479 or->async_error = error;
479 or->req_errors = req->errors ? : error; 480 or->req_errors = req->errors ? : error;
480 or->sense_len = req->sense_len; 481 or->sense_len = scsi_req(req)->sense_len;
482 if (or->sense_len)
483 memcpy(or->sense, scsi_req(req)->sense, or->sense_len);
481 if (or->out.req) 484 if (or->out.req)
482 or->out.residual = or->out.req->resid_len; 485 or->out.residual = scsi_req(or->out.req)->resid_len;
483 if (or->in.req) 486 if (or->in.req)
484 or->in.residual = or->in.req->resid_len; 487 or->in.residual = scsi_req(or->in.req)->resid_len;
485} 488}
486 489
487int osd_execute_request(struct osd_request *or) 490int osd_execute_request(struct osd_request *or)
@@ -1565,7 +1568,7 @@ static struct request *_make_request(struct request_queue *q, bool has_write,
1565 req = blk_get_request(q, has_write ? WRITE : READ, flags); 1568 req = blk_get_request(q, has_write ? WRITE : READ, flags);
1566 if (IS_ERR(req)) 1569 if (IS_ERR(req))
1567 return req; 1570 return req;
1568 blk_rq_set_block_pc(req); 1571 scsi_req_init(req);
1569 1572
1570 for_each_bio(bio) { 1573 for_each_bio(bio) {
1571 struct bio *bounce_bio = bio; 1574 struct bio *bounce_bio = bio;
@@ -1599,8 +1602,6 @@ static int _init_blk_request(struct osd_request *or,
1599 1602
1600 req->timeout = or->timeout; 1603 req->timeout = or->timeout;
1601 req->retries = or->retries; 1604 req->retries = or->retries;
1602 req->sense = or->sense;
1603 req->sense_len = 0;
1604 1605
1605 if (has_out) { 1606 if (has_out) {
1606 or->out.req = req; 1607 or->out.req = req;
@@ -1612,7 +1613,7 @@ static int _init_blk_request(struct osd_request *or,
1612 ret = PTR_ERR(req); 1613 ret = PTR_ERR(req);
1613 goto out; 1614 goto out;
1614 } 1615 }
1615 blk_rq_set_block_pc(req); 1616 scsi_req_init(req);
1616 or->in.req = or->request->next_rq = req; 1617 or->in.req = or->request->next_rq = req;
1617 } 1618 }
1618 } else if (has_in) 1619 } else if (has_in)
@@ -1699,8 +1700,8 @@ int osd_finalize_request(struct osd_request *or,
1699 1700
1700 osd_sec_sign_cdb(&or->cdb, cap_key); 1701 osd_sec_sign_cdb(&or->cdb, cap_key);
1701 1702
1702 or->request->cmd = or->cdb.buff; 1703 scsi_req(or->request)->cmd = or->cdb.buff;
1703 or->request->cmd_len = _osd_req_cdb_len(or); 1704 scsi_req(or->request)->cmd_len = _osd_req_cdb_len(or);
1704 1705
1705 return 0; 1706 return 0;
1706} 1707}
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index e8196c55b633..d314aa5c71cf 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -322,6 +322,7 @@ static int osst_chk_result(struct osst_tape * STp, struct osst_request * SRpnt)
322/* Wakeup from interrupt */ 322/* Wakeup from interrupt */
323static void osst_end_async(struct request *req, int update) 323static void osst_end_async(struct request *req, int update)
324{ 324{
325 struct scsi_request *rq = scsi_req(req);
325 struct osst_request *SRpnt = req->end_io_data; 326 struct osst_request *SRpnt = req->end_io_data;
326 struct osst_tape *STp = SRpnt->stp; 327 struct osst_tape *STp = SRpnt->stp;
327 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 328 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
@@ -330,6 +331,8 @@ static void osst_end_async(struct request *req, int update)
330#if DEBUG 331#if DEBUG
331 STp->write_pending = 0; 332 STp->write_pending = 0;
332#endif 333#endif
334 if (rq->sense_len)
335 memcpy(SRpnt->sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
333 if (SRpnt->waiting) 336 if (SRpnt->waiting)
334 complete(SRpnt->waiting); 337 complete(SRpnt->waiting);
335 338
@@ -357,6 +360,7 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
357 int use_sg, int timeout, int retries) 360 int use_sg, int timeout, int retries)
358{ 361{
359 struct request *req; 362 struct request *req;
363 struct scsi_request *rq;
360 struct page **pages = NULL; 364 struct page **pages = NULL;
361 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 365 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
362 366
@@ -367,7 +371,8 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
367 if (IS_ERR(req)) 371 if (IS_ERR(req))
368 return DRIVER_ERROR << 24; 372 return DRIVER_ERROR << 24;
369 373
370 blk_rq_set_block_pc(req); 374 rq = scsi_req(req);
375 scsi_req_init(req);
371 req->rq_flags |= RQF_QUIET; 376 req->rq_flags |= RQF_QUIET;
372 377
373 SRpnt->bio = NULL; 378 SRpnt->bio = NULL;
@@ -404,11 +409,9 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
404 goto free_req; 409 goto free_req;
405 } 410 }
406 411
407 req->cmd_len = cmd_len; 412 rq->cmd_len = cmd_len;
408 memset(req->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */ 413 memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
409 memcpy(req->cmd, cmd, req->cmd_len); 414 memcpy(rq->cmd, cmd, rq->cmd_len);
410 req->sense = SRpnt->sense;
411 req->sense_len = 0;
412 req->timeout = timeout; 415 req->timeout = timeout;
413 req->retries = retries; 416 req->retries = retries;
414 req->end_io_data = SRpnt; 417 req->end_io_data = SRpnt;
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 1bf8061ff803..40ca75bbcb9d 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -921,7 +921,7 @@ qla2x00_process_loopback(struct bsg_job *bsg_job)
921 921
922 bsg_job->reply_len = sizeof(struct fc_bsg_reply) + 922 bsg_job->reply_len = sizeof(struct fc_bsg_reply) +
923 sizeof(response) + sizeof(uint8_t); 923 sizeof(response) + sizeof(uint8_t);
924 fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) + 924 fw_sts_ptr = ((uint8_t *)scsi_req(bsg_job->req)->sense) +
925 sizeof(struct fc_bsg_reply); 925 sizeof(struct fc_bsg_reply);
926 memcpy(fw_sts_ptr, response, sizeof(response)); 926 memcpy(fw_sts_ptr, response, sizeof(response));
927 fw_sts_ptr += sizeof(response); 927 fw_sts_ptr += sizeof(response);
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index dc88a09f9043..67e157d81da8 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -1468,7 +1468,8 @@ qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
1468 type, sp->handle, comp_status, fw_status[1], fw_status[2], 1468 type, sp->handle, comp_status, fw_status[1], fw_status[2],
1469 le16_to_cpu(((struct els_sts_entry_24xx *) 1469 le16_to_cpu(((struct els_sts_entry_24xx *)
1470 pkt)->total_byte_count)); 1470 pkt)->total_byte_count));
1471 fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply); 1471 fw_sts_ptr = ((uint8_t*)scsi_req(bsg_job->req)->sense) +
1472 sizeof(struct fc_bsg_reply);
1472 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status)); 1473 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
1473 } 1474 }
1474 else { 1475 else {
@@ -1482,7 +1483,8 @@ qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
1482 pkt)->error_subcode_2)); 1483 pkt)->error_subcode_2));
1483 res = DID_ERROR << 16; 1484 res = DID_ERROR << 16;
1484 bsg_reply->reply_payload_rcv_len = 0; 1485 bsg_reply->reply_payload_rcv_len = 0;
1485 fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply); 1486 fw_sts_ptr = ((uint8_t*)scsi_req(bsg_job->req)->sense) +
1487 sizeof(struct fc_bsg_reply);
1486 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status)); 1488 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
1487 } 1489 }
1488 ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056, 1490 ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
diff --git a/drivers/scsi/qla2xxx/qla_mr.c b/drivers/scsi/qla2xxx/qla_mr.c
index 02f1de18bc2b..96c33e292eba 100644
--- a/drivers/scsi/qla2xxx/qla_mr.c
+++ b/drivers/scsi/qla2xxx/qla_mr.c
@@ -2244,7 +2244,7 @@ qlafx00_ioctl_iosb_entry(scsi_qla_host_t *vha, struct req_que *req,
2244 memcpy(fstatus.reserved_3, 2244 memcpy(fstatus.reserved_3,
2245 pkt->reserved_2, 20 * sizeof(uint8_t)); 2245 pkt->reserved_2, 20 * sizeof(uint8_t));
2246 2246
2247 fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) + 2247 fw_sts_ptr = ((uint8_t *)scsi_req(bsg_job->req)->sense) +
2248 sizeof(struct fc_bsg_reply); 2248 sizeof(struct fc_bsg_reply);
2249 2249
2250 memcpy(fw_sts_ptr, (uint8_t *)&fstatus, 2250 memcpy(fw_sts_ptr, (uint8_t *)&fstatus,
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 7c084600827b..4b40f746d534 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1968,6 +1968,7 @@ static void eh_lock_door_done(struct request *req, int uptodate)
1968static void scsi_eh_lock_door(struct scsi_device *sdev) 1968static void scsi_eh_lock_door(struct scsi_device *sdev)
1969{ 1969{
1970 struct request *req; 1970 struct request *req;
1971 struct scsi_request *rq;
1971 1972
1972 /* 1973 /*
1973 * blk_get_request with GFP_KERNEL (__GFP_RECLAIM) sleeps until a 1974 * blk_get_request with GFP_KERNEL (__GFP_RECLAIM) sleeps until a
@@ -1976,17 +1977,16 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
1976 req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL); 1977 req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL);
1977 if (IS_ERR(req)) 1978 if (IS_ERR(req))
1978 return; 1979 return;
1980 rq = scsi_req(req);
1981 scsi_req_init(req);
1979 1982
1980 blk_rq_set_block_pc(req); 1983 rq->cmd[0] = ALLOW_MEDIUM_REMOVAL;
1981 1984 rq->cmd[1] = 0;
1982 req->cmd[0] = ALLOW_MEDIUM_REMOVAL; 1985 rq->cmd[2] = 0;
1983 req->cmd[1] = 0; 1986 rq->cmd[3] = 0;
1984 req->cmd[2] = 0; 1987 rq->cmd[4] = SCSI_REMOVAL_PREVENT;
1985 req->cmd[3] = 0; 1988 rq->cmd[5] = 0;
1986 req->cmd[4] = SCSI_REMOVAL_PREVENT; 1989 rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
1987 req->cmd[5] = 0;
1988
1989 req->cmd_len = COMMAND_SIZE(req->cmd[0]);
1990 1990
1991 req->rq_flags |= RQF_QUIET; 1991 req->rq_flags |= RQF_QUIET;
1992 req->timeout = 10 * HZ; 1992 req->timeout = 10 * HZ;
@@ -2355,7 +2355,7 @@ scsi_ioctl_reset(struct scsi_device *dev, int __user *arg)
2355 scmd = (struct scsi_cmnd *)(rq + 1); 2355 scmd = (struct scsi_cmnd *)(rq + 1);
2356 scsi_init_command(dev, scmd); 2356 scsi_init_command(dev, scmd);
2357 scmd->request = rq; 2357 scmd->request = rq;
2358 scmd->cmnd = rq->cmd; 2358 scmd->cmnd = scsi_req(rq)->cmd;
2359 2359
2360 scmd->scsi_done = scsi_reset_provider_done_command; 2360 scmd->scsi_done = scsi_reset_provider_done_command;
2361 memset(&scmd->sdb, 0, sizeof(scmd->sdb)); 2361 memset(&scmd->sdb, 0, sizeof(scmd->sdb));
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 81ff5ad23b83..8188e5c71f75 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -220,21 +220,21 @@ static int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
220{ 220{
221 struct request *req; 221 struct request *req;
222 int write = (data_direction == DMA_TO_DEVICE); 222 int write = (data_direction == DMA_TO_DEVICE);
223 struct scsi_request *rq;
223 int ret = DRIVER_ERROR << 24; 224 int ret = DRIVER_ERROR << 24;
224 225
225 req = blk_get_request(sdev->request_queue, write, __GFP_RECLAIM); 226 req = blk_get_request(sdev->request_queue, write, __GFP_RECLAIM);
226 if (IS_ERR(req)) 227 if (IS_ERR(req))
227 return ret; 228 return ret;
228 blk_rq_set_block_pc(req); 229 rq = scsi_req(req);
230 scsi_req_init(req);
229 231
230 if (bufflen && blk_rq_map_kern(sdev->request_queue, req, 232 if (bufflen && blk_rq_map_kern(sdev->request_queue, req,
231 buffer, bufflen, __GFP_RECLAIM)) 233 buffer, bufflen, __GFP_RECLAIM))
232 goto out; 234 goto out;
233 235
234 req->cmd_len = COMMAND_SIZE(cmd[0]); 236 rq->cmd_len = COMMAND_SIZE(cmd[0]);
235 memcpy(req->cmd, cmd, req->cmd_len); 237 memcpy(rq->cmd, cmd, rq->cmd_len);
236 req->sense = sense;
237 req->sense_len = 0;
238 req->retries = retries; 238 req->retries = retries;
239 req->timeout = timeout; 239 req->timeout = timeout;
240 req->cmd_flags |= flags; 240 req->cmd_flags |= flags;
@@ -251,11 +251,13 @@ static int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
251 * is invalid. Prevent the garbage from being misinterpreted 251 * is invalid. Prevent the garbage from being misinterpreted
252 * and prevent security leaks by zeroing out the excess data. 252 * and prevent security leaks by zeroing out the excess data.
253 */ 253 */
254 if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen)) 254 if (unlikely(rq->resid_len > 0 && rq->resid_len <= bufflen))
255 memset(buffer + (bufflen - req->resid_len), 0, req->resid_len); 255 memset(buffer + (bufflen - rq->resid_len), 0, rq->resid_len);
256 256
257 if (resid) 257 if (resid)
258 *resid = req->resid_len; 258 *resid = rq->resid_len;
259 if (sense && rq->sense_len)
260 memcpy(sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
259 ret = req->errors; 261 ret = req->errors;
260 out: 262 out:
261 blk_put_request(req); 263 blk_put_request(req);
@@ -806,16 +808,13 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
806 808
807 if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */ 809 if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */
808 if (result) { 810 if (result) {
809 if (sense_valid && req->sense) { 811 if (sense_valid) {
810 /* 812 /*
811 * SG_IO wants current and deferred errors 813 * SG_IO wants current and deferred errors
812 */ 814 */
813 int len = 8 + cmd->sense_buffer[7]; 815 scsi_req(req)->sense_len =
814 816 min(8 + cmd->sense_buffer[7],
815 if (len > SCSI_SENSE_BUFFERSIZE) 817 SCSI_SENSE_BUFFERSIZE);
816 len = SCSI_SENSE_BUFFERSIZE;
817 memcpy(req->sense, cmd->sense_buffer, len);
818 req->sense_len = len;
819 } 818 }
820 if (!sense_deferred) 819 if (!sense_deferred)
821 error = __scsi_error_from_host_byte(cmd, result); 820 error = __scsi_error_from_host_byte(cmd, result);
@@ -825,14 +824,14 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
825 */ 824 */
826 req->errors = cmd->result; 825 req->errors = cmd->result;
827 826
828 req->resid_len = scsi_get_resid(cmd); 827 scsi_req(req)->resid_len = scsi_get_resid(cmd);
829 828
830 if (scsi_bidi_cmnd(cmd)) { 829 if (scsi_bidi_cmnd(cmd)) {
831 /* 830 /*
832 * Bidi commands Must be complete as a whole, 831 * Bidi commands Must be complete as a whole,
833 * both sides at once. 832 * both sides at once.
834 */ 833 */
835 req->next_rq->resid_len = scsi_in(cmd)->resid; 834 scsi_req(req->next_rq)->resid_len = scsi_in(cmd)->resid;
836 if (scsi_end_request(req, 0, blk_rq_bytes(req), 835 if (scsi_end_request(req, 0, blk_rq_bytes(req),
837 blk_rq_bytes(req->next_rq))) 836 blk_rq_bytes(req->next_rq)))
838 BUG(); 837 BUG();
@@ -1165,7 +1164,10 @@ void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd)
1165 void *prot = cmd->prot_sdb; 1164 void *prot = cmd->prot_sdb;
1166 unsigned long flags; 1165 unsigned long flags;
1167 1166
1168 memset(cmd, 0, sizeof(*cmd)); 1167 /* zero out the cmd, except for the embedded scsi_request */
1168 memset((char *)cmd + sizeof(cmd->req), 0,
1169 sizeof(*cmd) - sizeof(cmd->req));
1170
1169 cmd->device = dev; 1171 cmd->device = dev;
1170 cmd->sense_buffer = buf; 1172 cmd->sense_buffer = buf;
1171 cmd->prot_sdb = prot; 1173 cmd->prot_sdb = prot;
@@ -1197,7 +1199,8 @@ static int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
1197 memset(&cmd->sdb, 0, sizeof(cmd->sdb)); 1199 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
1198 } 1200 }
1199 1201
1200 cmd->cmd_len = req->cmd_len; 1202 cmd->cmd_len = scsi_req(req)->cmd_len;
1203 cmd->cmnd = scsi_req(req)->cmd;
1201 cmd->transfersize = blk_rq_bytes(req); 1204 cmd->transfersize = blk_rq_bytes(req);
1202 cmd->allowed = req->retries; 1205 cmd->allowed = req->retries;
1203 return BLKPREP_OK; 1206 return BLKPREP_OK;
@@ -1217,6 +1220,7 @@ static int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)
1217 return ret; 1220 return ret;
1218 } 1221 }
1219 1222
1223 cmd->cmnd = scsi_req(req)->cmd = scsi_req(req)->__cmd;
1220 memset(cmd->cmnd, 0, BLK_MAX_CDB); 1224 memset(cmd->cmnd, 0, BLK_MAX_CDB);
1221 return scsi_cmd_to_driver(cmd)->init_command(cmd); 1225 return scsi_cmd_to_driver(cmd)->init_command(cmd);
1222} 1226}
@@ -1355,7 +1359,6 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
1355 1359
1356 cmd->tag = req->tag; 1360 cmd->tag = req->tag;
1357 cmd->request = req; 1361 cmd->request = req;
1358 cmd->cmnd = req->cmd;
1359 cmd->prot_op = SCSI_PROT_NORMAL; 1362 cmd->prot_op = SCSI_PROT_NORMAL;
1360 1363
1361 ret = scsi_setup_cmnd(sdev, req); 1364 ret = scsi_setup_cmnd(sdev, req);
@@ -1874,7 +1877,9 @@ static int scsi_mq_prep_fn(struct request *req)
1874 unsigned char *sense_buf = cmd->sense_buffer; 1877 unsigned char *sense_buf = cmd->sense_buffer;
1875 struct scatterlist *sg; 1878 struct scatterlist *sg;
1876 1879
1877 memset(cmd, 0, sizeof(struct scsi_cmnd)); 1880 /* zero out the cmd, except for the embedded scsi_request */
1881 memset((char *)cmd + sizeof(cmd->req), 0,
1882 sizeof(*cmd) - sizeof(cmd->req));
1878 1883
1879 req->special = cmd; 1884 req->special = cmd;
1880 1885
@@ -1884,7 +1889,6 @@ static int scsi_mq_prep_fn(struct request *req)
1884 1889
1885 cmd->tag = req->tag; 1890 cmd->tag = req->tag;
1886 1891
1887 cmd->cmnd = req->cmd;
1888 cmd->prot_op = SCSI_PROT_NORMAL; 1892 cmd->prot_op = SCSI_PROT_NORMAL;
1889 1893
1890 INIT_LIST_HEAD(&cmd->list); 1894 INIT_LIST_HEAD(&cmd->list);
@@ -1959,7 +1963,6 @@ static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
1959 if (!scsi_host_queue_ready(q, shost, sdev)) 1963 if (!scsi_host_queue_ready(q, shost, sdev))
1960 goto out_dec_target_busy; 1964 goto out_dec_target_busy;
1961 1965
1962
1963 if (!(req->rq_flags & RQF_DONTPREP)) { 1966 if (!(req->rq_flags & RQF_DONTPREP)) {
1964 ret = prep_to_mq(scsi_mq_prep_fn(req)); 1967 ret = prep_to_mq(scsi_mq_prep_fn(req));
1965 if (ret != BLK_MQ_RQ_QUEUE_OK) 1968 if (ret != BLK_MQ_RQ_QUEUE_OK)
@@ -2036,6 +2039,7 @@ static int scsi_init_request(void *data, struct request *rq,
2036 scsi_alloc_sense_buffer(shost, GFP_KERNEL, numa_node); 2039 scsi_alloc_sense_buffer(shost, GFP_KERNEL, numa_node);
2037 if (!cmd->sense_buffer) 2040 if (!cmd->sense_buffer)
2038 return -ENOMEM; 2041 return -ENOMEM;
2042 cmd->req.sense = cmd->sense_buffer;
2039 return 0; 2043 return 0;
2040} 2044}
2041 2045
@@ -2125,6 +2129,7 @@ static int scsi_init_rq(struct request_queue *q, struct request *rq, gfp_t gfp)
2125 cmd->sense_buffer = scsi_alloc_sense_buffer(shost, gfp, NUMA_NO_NODE); 2129 cmd->sense_buffer = scsi_alloc_sense_buffer(shost, gfp, NUMA_NO_NODE);
2126 if (!cmd->sense_buffer) 2130 if (!cmd->sense_buffer)
2127 goto fail; 2131 goto fail;
2132 cmd->req.sense = cmd->sense_buffer;
2128 2133
2129 if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) { 2134 if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
2130 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp); 2135 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp);
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 60b651bfaa01..126a5ee00987 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -33,6 +33,7 @@
33#include <linux/bsg.h> 33#include <linux/bsg.h>
34 34
35#include <scsi/scsi.h> 35#include <scsi/scsi.h>
36#include <scsi/scsi_request.h>
36#include <scsi/scsi_device.h> 37#include <scsi/scsi_device.h>
37#include <scsi/scsi_host.h> 38#include <scsi/scsi_host.h>
38#include <scsi/scsi_transport.h> 39#include <scsi/scsi_transport.h>
@@ -177,6 +178,10 @@ static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
177 while ((req = blk_fetch_request(q)) != NULL) { 178 while ((req = blk_fetch_request(q)) != NULL) {
178 spin_unlock_irq(q->queue_lock); 179 spin_unlock_irq(q->queue_lock);
179 180
181 scsi_req(req)->resid_len = blk_rq_bytes(req);
182 if (req->next_rq)
183 scsi_req(req->next_rq)->resid_len =
184 blk_rq_bytes(req->next_rq);
180 handler = to_sas_internal(shost->transportt)->f->smp_handler; 185 handler = to_sas_internal(shost->transportt)->f->smp_handler;
181 ret = handler(shost, rphy, req); 186 ret = handler(shost, rphy, req);
182 req->errors = ret; 187 req->errors = ret;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 0b09638fa39b..c779986edb43 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -781,7 +781,7 @@ static int sd_setup_discard_cmnd(struct scsi_cmnd *cmd)
781 rq->special_vec.bv_len = len; 781 rq->special_vec.bv_len = len;
782 782
783 rq->rq_flags |= RQF_SPECIAL_PAYLOAD; 783 rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
784 rq->resid_len = len; 784 scsi_req(rq)->resid_len = len;
785 785
786 ret = scsi_init_io(cmd); 786 ret = scsi_init_io(cmd);
787out: 787out:
@@ -1164,7 +1164,7 @@ static void sd_uninit_command(struct scsi_cmnd *SCpnt)
1164 if (rq->rq_flags & RQF_SPECIAL_PAYLOAD) 1164 if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
1165 __free_page(rq->special_vec.bv_page); 1165 __free_page(rq->special_vec.bv_page);
1166 1166
1167 if (SCpnt->cmnd != rq->cmd) { 1167 if (SCpnt->cmnd != scsi_req(rq)->cmd) {
1168 mempool_free(SCpnt->cmnd, sd_cdb_pool); 1168 mempool_free(SCpnt->cmnd, sd_cdb_pool);
1169 SCpnt->cmnd = NULL; 1169 SCpnt->cmnd = NULL;
1170 SCpnt->cmd_len = 0; 1170 SCpnt->cmd_len = 0;
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index dbe5b4b95df0..226a8def7a8b 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -781,9 +781,7 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
781 } 781 }
782 if (atomic_read(&sdp->detaching)) { 782 if (atomic_read(&sdp->detaching)) {
783 if (srp->bio) { 783 if (srp->bio) {
784 if (srp->rq->cmd != srp->rq->__cmd) 784 scsi_req_free_cmd(scsi_req(srp->rq));
785 kfree(srp->rq->cmd);
786
787 blk_end_request_all(srp->rq, -EIO); 785 blk_end_request_all(srp->rq, -EIO);
788 srp->rq = NULL; 786 srp->rq = NULL;
789 } 787 }
@@ -1279,6 +1277,7 @@ static void
1279sg_rq_end_io(struct request *rq, int uptodate) 1277sg_rq_end_io(struct request *rq, int uptodate)
1280{ 1278{
1281 struct sg_request *srp = rq->end_io_data; 1279 struct sg_request *srp = rq->end_io_data;
1280 struct scsi_request *req = scsi_req(rq);
1282 Sg_device *sdp; 1281 Sg_device *sdp;
1283 Sg_fd *sfp; 1282 Sg_fd *sfp;
1284 unsigned long iflags; 1283 unsigned long iflags;
@@ -1297,9 +1296,9 @@ sg_rq_end_io(struct request *rq, int uptodate)
1297 if (unlikely(atomic_read(&sdp->detaching))) 1296 if (unlikely(atomic_read(&sdp->detaching)))
1298 pr_info("%s: device detaching\n", __func__); 1297 pr_info("%s: device detaching\n", __func__);
1299 1298
1300 sense = rq->sense; 1299 sense = req->sense;
1301 result = rq->errors; 1300 result = rq->errors;
1302 resid = rq->resid_len; 1301 resid = req->resid_len;
1303 1302
1304 SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp, 1303 SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
1305 "sg_cmd_done: pack_id=%d, res=0x%x\n", 1304 "sg_cmd_done: pack_id=%d, res=0x%x\n",
@@ -1333,6 +1332,10 @@ sg_rq_end_io(struct request *rq, int uptodate)
1333 sdp->device->changed = 1; 1332 sdp->device->changed = 1;
1334 } 1333 }
1335 } 1334 }
1335
1336 if (req->sense_len)
1337 memcpy(srp->sense_b, req->sense, SCSI_SENSE_BUFFERSIZE);
1338
1336 /* Rely on write phase to clean out srp status values, so no "else" */ 1339 /* Rely on write phase to clean out srp status values, so no "else" */
1337 1340
1338 /* 1341 /*
@@ -1342,8 +1345,7 @@ sg_rq_end_io(struct request *rq, int uptodate)
1342 * blk_rq_unmap_user() can be called from user context. 1345 * blk_rq_unmap_user() can be called from user context.
1343 */ 1346 */
1344 srp->rq = NULL; 1347 srp->rq = NULL;
1345 if (rq->cmd != rq->__cmd) 1348 scsi_req_free_cmd(scsi_req(rq));
1346 kfree(rq->cmd);
1347 __blk_put_request(rq->q, rq); 1349 __blk_put_request(rq->q, rq);
1348 1350
1349 write_lock_irqsave(&sfp->rq_list_lock, iflags); 1351 write_lock_irqsave(&sfp->rq_list_lock, iflags);
@@ -1658,6 +1660,7 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
1658{ 1660{
1659 int res; 1661 int res;
1660 struct request *rq; 1662 struct request *rq;
1663 struct scsi_request *req;
1661 Sg_fd *sfp = srp->parentfp; 1664 Sg_fd *sfp = srp->parentfp;
1662 sg_io_hdr_t *hp = &srp->header; 1665 sg_io_hdr_t *hp = &srp->header;
1663 int dxfer_len = (int) hp->dxfer_len; 1666 int dxfer_len = (int) hp->dxfer_len;
@@ -1700,17 +1703,17 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
1700 kfree(long_cmdp); 1703 kfree(long_cmdp);
1701 return PTR_ERR(rq); 1704 return PTR_ERR(rq);
1702 } 1705 }
1706 req = scsi_req(rq);
1703 1707
1704 blk_rq_set_block_pc(rq); 1708 scsi_req_init(rq);
1705 1709
1706 if (hp->cmd_len > BLK_MAX_CDB) 1710 if (hp->cmd_len > BLK_MAX_CDB)
1707 rq->cmd = long_cmdp; 1711 req->cmd = long_cmdp;
1708 memcpy(rq->cmd, cmd, hp->cmd_len); 1712 memcpy(req->cmd, cmd, hp->cmd_len);
1709 rq->cmd_len = hp->cmd_len; 1713 req->cmd_len = hp->cmd_len;
1710 1714
1711 srp->rq = rq; 1715 srp->rq = rq;
1712 rq->end_io_data = srp; 1716 rq->end_io_data = srp;
1713 rq->sense = srp->sense_b;
1714 rq->retries = SG_DEFAULT_RETRIES; 1717 rq->retries = SG_DEFAULT_RETRIES;
1715 1718
1716 if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE)) 1719 if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
@@ -1786,8 +1789,7 @@ sg_finish_rem_req(Sg_request *srp)
1786 ret = blk_rq_unmap_user(srp->bio); 1789 ret = blk_rq_unmap_user(srp->bio);
1787 1790
1788 if (srp->rq) { 1791 if (srp->rq) {
1789 if (srp->rq->cmd != srp->rq->__cmd) 1792 scsi_req_free_cmd(scsi_req(srp->rq));
1790 kfree(srp->rq->cmd);
1791 blk_put_request(srp->rq); 1793 blk_put_request(srp->rq);
1792 } 1794 }
1793 1795
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 5f35b863e1a7..4af900100a24 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -475,7 +475,7 @@ static void st_do_stats(struct scsi_tape *STp, struct request *req)
475 ktime_t now; 475 ktime_t now;
476 476
477 now = ktime_get(); 477 now = ktime_get();
478 if (req->cmd[0] == WRITE_6) { 478 if (scsi_req(req)->cmd[0] == WRITE_6) {
479 now = ktime_sub(now, STp->stats->write_time); 479 now = ktime_sub(now, STp->stats->write_time);
480 atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time); 480 atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time);
481 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time); 481 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
@@ -489,7 +489,7 @@ static void st_do_stats(struct scsi_tape *STp, struct request *req)
489 } else 489 } else
490 atomic64_add(atomic_read(&STp->stats->last_write_size), 490 atomic64_add(atomic_read(&STp->stats->last_write_size),
491 &STp->stats->write_byte_cnt); 491 &STp->stats->write_byte_cnt);
492 } else if (req->cmd[0] == READ_6) { 492 } else if (scsi_req(req)->cmd[0] == READ_6) {
493 now = ktime_sub(now, STp->stats->read_time); 493 now = ktime_sub(now, STp->stats->read_time);
494 atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time); 494 atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time);
495 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time); 495 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
@@ -514,15 +514,18 @@ static void st_do_stats(struct scsi_tape *STp, struct request *req)
514static void st_scsi_execute_end(struct request *req, int uptodate) 514static void st_scsi_execute_end(struct request *req, int uptodate)
515{ 515{
516 struct st_request *SRpnt = req->end_io_data; 516 struct st_request *SRpnt = req->end_io_data;
517 struct scsi_request *rq = scsi_req(req);
517 struct scsi_tape *STp = SRpnt->stp; 518 struct scsi_tape *STp = SRpnt->stp;
518 struct bio *tmp; 519 struct bio *tmp;
519 520
520 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors; 521 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
521 STp->buffer->cmdstat.residual = req->resid_len; 522 STp->buffer->cmdstat.residual = rq->resid_len;
522 523
523 st_do_stats(STp, req); 524 st_do_stats(STp, req);
524 525
525 tmp = SRpnt->bio; 526 tmp = SRpnt->bio;
527 if (rq->sense_len)
528 memcpy(SRpnt->sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
526 if (SRpnt->waiting) 529 if (SRpnt->waiting)
527 complete(SRpnt->waiting); 530 complete(SRpnt->waiting);
528 531
@@ -535,6 +538,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
535 int timeout, int retries) 538 int timeout, int retries)
536{ 539{
537 struct request *req; 540 struct request *req;
541 struct scsi_request *rq;
538 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 542 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
539 int err = 0; 543 int err = 0;
540 int write = (data_direction == DMA_TO_DEVICE); 544 int write = (data_direction == DMA_TO_DEVICE);
@@ -544,8 +548,8 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
544 GFP_KERNEL); 548 GFP_KERNEL);
545 if (IS_ERR(req)) 549 if (IS_ERR(req))
546 return DRIVER_ERROR << 24; 550 return DRIVER_ERROR << 24;
547 551 rq = scsi_req(req);
548 blk_rq_set_block_pc(req); 552 scsi_req_init(req);
549 req->rq_flags |= RQF_QUIET; 553 req->rq_flags |= RQF_QUIET;
550 554
551 mdata->null_mapped = 1; 555 mdata->null_mapped = 1;
@@ -571,11 +575,9 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
571 } 575 }
572 576
573 SRpnt->bio = req->bio; 577 SRpnt->bio = req->bio;
574 req->cmd_len = COMMAND_SIZE(cmd[0]); 578 rq->cmd_len = COMMAND_SIZE(cmd[0]);
575 memset(req->cmd, 0, BLK_MAX_CDB); 579 memset(rq->cmd, 0, BLK_MAX_CDB);
576 memcpy(req->cmd, cmd, req->cmd_len); 580 memcpy(rq->cmd, cmd, rq->cmd_len);
577 req->sense = SRpnt->sense;
578 req->sense_len = 0;
579 req->timeout = timeout; 581 req->timeout = timeout;
580 req->retries = retries; 582 req->retries = retries;
581 req->end_io_data = SRpnt; 583 req->end_io_data = SRpnt;
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 04d7aa7390d0..e52f4e1a4675 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -1013,7 +1013,7 @@ pscsi_execute_cmd(struct se_cmd *cmd)
1013 goto fail; 1013 goto fail;
1014 } 1014 }
1015 1015
1016 blk_rq_set_block_pc(req); 1016 scsi_req_init(req);
1017 1017
1018 if (sgl) { 1018 if (sgl) {
1019 ret = pscsi_map_sg(cmd, sgl, sgl_nents, req); 1019 ret = pscsi_map_sg(cmd, sgl, sgl_nents, req);
@@ -1023,10 +1023,8 @@ pscsi_execute_cmd(struct se_cmd *cmd)
1023 1023
1024 req->end_io = pscsi_req_done; 1024 req->end_io = pscsi_req_done;
1025 req->end_io_data = cmd; 1025 req->end_io_data = cmd;
1026 req->cmd_len = scsi_command_size(pt->pscsi_cdb); 1026 scsi_req(req)->cmd_len = scsi_command_size(pt->pscsi_cdb);
1027 req->cmd = &pt->pscsi_cdb[0]; 1027 scsi_req(req)->cmd = &pt->pscsi_cdb[0];
1028 req->sense = &pt->pscsi_sense[0];
1029 req->sense_len = 0;
1030 if (pdv->pdv_sd->type == TYPE_DISK) 1028 if (pdv->pdv_sd->type == TYPE_DISK)
1031 req->timeout = PS_TIMEOUT_DISK; 1029 req->timeout = PS_TIMEOUT_DISK;
1032 else 1030 else
@@ -1075,7 +1073,7 @@ static void pscsi_req_done(struct request *req, int uptodate)
1075 struct pscsi_plugin_task *pt = cmd->priv; 1073 struct pscsi_plugin_task *pt = cmd->priv;
1076 1074
1077 pt->pscsi_result = req->errors; 1075 pt->pscsi_result = req->errors;
1078 pt->pscsi_resid = req->resid_len; 1076 pt->pscsi_resid = scsi_req(req)->resid_len;
1079 1077
1080 cmd->scsi_status = status_byte(pt->pscsi_result) << 1; 1078 cmd->scsi_status = status_byte(pt->pscsi_result) << 1;
1081 if (cmd->scsi_status) { 1079 if (cmd->scsi_status) {
@@ -1096,6 +1094,7 @@ static void pscsi_req_done(struct request *req, int uptodate)
1096 break; 1094 break;
1097 } 1095 }
1098 1096
1097 memcpy(pt->pscsi_sense, scsi_req(req)->sense, TRANSPORT_SENSE_BUFFER);
1099 __blk_put_request(req->q, req); 1098 __blk_put_request(req->q, req);
1100 kfree(pt); 1099 kfree(pt);
1101} 1100}
diff --git a/fs/nfsd/blocklayout.c b/fs/nfsd/blocklayout.c
index 0780ff864539..930d98caab5b 100644
--- a/fs/nfsd/blocklayout.c
+++ b/fs/nfsd/blocklayout.c
@@ -10,6 +10,7 @@
10#include <linux/nfsd/debug.h> 10#include <linux/nfsd/debug.h>
11#include <scsi/scsi_proto.h> 11#include <scsi/scsi_proto.h>
12#include <scsi/scsi_common.h> 12#include <scsi/scsi_common.h>
13#include <scsi/scsi_request.h>
13 14
14#include "blocklayoutxdr.h" 15#include "blocklayoutxdr.h"
15#include "pnfs.h" 16#include "pnfs.h"
@@ -213,6 +214,7 @@ static int nfsd4_scsi_identify_device(struct block_device *bdev,
213{ 214{
214 struct request_queue *q = bdev->bd_disk->queue; 215 struct request_queue *q = bdev->bd_disk->queue;
215 struct request *rq; 216 struct request *rq;
217 struct scsi_request *req;
216 size_t bufflen = 252, len, id_len; 218 size_t bufflen = 252, len, id_len;
217 u8 *buf, *d, type, assoc; 219 u8 *buf, *d, type, assoc;
218 int error; 220 int error;
@@ -226,18 +228,19 @@ static int nfsd4_scsi_identify_device(struct block_device *bdev,
226 error = -ENOMEM; 228 error = -ENOMEM;
227 goto out_free_buf; 229 goto out_free_buf;
228 } 230 }
229 blk_rq_set_block_pc(rq); 231 req = scsi_req(rq);
232 scsi_req_init(rq);
230 233
231 error = blk_rq_map_kern(q, rq, buf, bufflen, GFP_KERNEL); 234 error = blk_rq_map_kern(q, rq, buf, bufflen, GFP_KERNEL);
232 if (error) 235 if (error)
233 goto out_put_request; 236 goto out_put_request;
234 237
235 rq->cmd[0] = INQUIRY; 238 req->cmd[0] = INQUIRY;
236 rq->cmd[1] = 1; 239 req->cmd[1] = 1;
237 rq->cmd[2] = 0x83; 240 req->cmd[2] = 0x83;
238 rq->cmd[3] = bufflen >> 8; 241 req->cmd[3] = bufflen >> 8;
239 rq->cmd[4] = bufflen & 0xff; 242 req->cmd[4] = bufflen & 0xff;
240 rq->cmd_len = COMMAND_SIZE(INQUIRY); 243 req->cmd_len = COMMAND_SIZE(INQUIRY);
241 244
242 error = blk_execute_rq(rq->q, NULL, rq, 1); 245 error = blk_execute_rq(rq->q, NULL, rq, 1);
243 if (error) { 246 if (error) {
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 461b7cf6af1d..e4c5f284fe2d 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -128,8 +128,6 @@ typedef __u32 __bitwise req_flags_t;
128#define RQF_NOMERGE_FLAGS \ 128#define RQF_NOMERGE_FLAGS \
129 (RQF_STARTED | RQF_SOFTBARRIER | RQF_FLUSH_SEQ | RQF_SPECIAL_PAYLOAD) 129 (RQF_STARTED | RQF_SOFTBARRIER | RQF_FLUSH_SEQ | RQF_SPECIAL_PAYLOAD)
130 130
131#define BLK_MAX_CDB 16
132
133/* 131/*
134 * Try to put the fields that are referenced together in the same cacheline. 132 * Try to put the fields that are referenced together in the same cacheline.
135 * 133 *
@@ -227,17 +225,7 @@ struct request {
227 225
228 int errors; 226 int errors;
229 227
230 /*
231 * when request is used as a packet command carrier
232 */
233 unsigned char __cmd[BLK_MAX_CDB];
234 unsigned char *cmd;
235 unsigned short cmd_len;
236
237 unsigned int extra_len; /* length of alignment and padding */ 228 unsigned int extra_len; /* length of alignment and padding */
238 unsigned int sense_len;
239 unsigned int resid_len; /* residual count */
240 void *sense;
241 229
242 unsigned long deadline; 230 unsigned long deadline;
243 struct list_head timeout_list; 231 struct list_head timeout_list;
@@ -925,7 +913,6 @@ extern void blk_rq_init(struct request_queue *q, struct request *rq);
925extern void blk_put_request(struct request *); 913extern void blk_put_request(struct request *);
926extern void __blk_put_request(struct request_queue *, struct request *); 914extern void __blk_put_request(struct request_queue *, struct request *);
927extern struct request *blk_get_request(struct request_queue *, int, gfp_t); 915extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
928extern void blk_rq_set_block_pc(struct request *);
929extern void blk_requeue_request(struct request_queue *, struct request *); 916extern void blk_requeue_request(struct request_queue *, struct request *);
930extern int blk_lld_busy(struct request_queue *q); 917extern int blk_lld_busy(struct request_queue *q);
931extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src, 918extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
diff --git a/include/linux/ide.h b/include/linux/ide.h
index a633898f36ac..086fbe172817 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -20,6 +20,7 @@
20#include <linux/mutex.h> 20#include <linux/mutex.h>
21/* for request_sense */ 21/* for request_sense */
22#include <linux/cdrom.h> 22#include <linux/cdrom.h>
23#include <scsi/scsi_cmnd.h>
23#include <asm/byteorder.h> 24#include <asm/byteorder.h>
24#include <asm/io.h> 25#include <asm/io.h>
25 26
@@ -52,6 +53,11 @@ enum ata_cmd_type_bits {
52 ((rq)->cmd_type == REQ_TYPE_ATA_PM_SUSPEND || \ 53 ((rq)->cmd_type == REQ_TYPE_ATA_PM_SUSPEND || \
53 (rq)->cmd_type == REQ_TYPE_ATA_PM_RESUME) 54 (rq)->cmd_type == REQ_TYPE_ATA_PM_RESUME)
54 55
56struct ide_request {
57 struct scsi_request sreq;
58 u8 sense[SCSI_SENSE_BUFFERSIZE];
59};
60
55/* Error codes returned in rq->errors to the higher part of the driver. */ 61/* Error codes returned in rq->errors to the higher part of the driver. */
56enum { 62enum {
57 IDE_DRV_ERROR_GENERAL = 101, 63 IDE_DRV_ERROR_GENERAL = 101,
@@ -579,7 +585,7 @@ struct ide_drive_s {
579 585
580 /* current sense rq and buffer */ 586 /* current sense rq and buffer */
581 bool sense_rq_armed; 587 bool sense_rq_armed;
582 struct request sense_rq; 588 struct request *sense_rq;
583 struct request_sense sense_data; 589 struct request_sense sense_data;
584}; 590};
585 591
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 9fc1aecfc813..f708f1acfc50 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -8,6 +8,7 @@
8#include <linux/timer.h> 8#include <linux/timer.h>
9#include <linux/scatterlist.h> 9#include <linux/scatterlist.h>
10#include <scsi/scsi_device.h> 10#include <scsi/scsi_device.h>
11#include <scsi/scsi_request.h>
11 12
12struct Scsi_Host; 13struct Scsi_Host;
13struct scsi_driver; 14struct scsi_driver;
@@ -57,6 +58,7 @@ struct scsi_pointer {
57#define SCMD_TAGGED (1 << 0) 58#define SCMD_TAGGED (1 << 0)
58 59
59struct scsi_cmnd { 60struct scsi_cmnd {
61 struct scsi_request req;
60 struct scsi_device *device; 62 struct scsi_device *device;
61 struct list_head list; /* scsi_cmnd participates in queue lists */ 63 struct list_head list; /* scsi_cmnd participates in queue lists */
62 struct list_head eh_entry; /* entry for the host eh_cmd_q */ 64 struct list_head eh_entry; /* entry for the host eh_cmd_q */
diff --git a/include/scsi/scsi_request.h b/include/scsi/scsi_request.h
new file mode 100644
index 000000000000..ba0aeb980f7e
--- /dev/null
+++ b/include/scsi/scsi_request.h
@@ -0,0 +1,30 @@
1#ifndef _SCSI_SCSI_REQUEST_H
2#define _SCSI_SCSI_REQUEST_H
3
4#include <linux/blk-mq.h>
5
6#define BLK_MAX_CDB 16
7
8struct scsi_request {
9 unsigned char __cmd[BLK_MAX_CDB];
10 unsigned char *cmd;
11 unsigned short cmd_len;
12 unsigned int sense_len;
13 unsigned int resid_len; /* residual count */
14 void *sense;
15};
16
17static inline struct scsi_request *scsi_req(struct request *rq)
18{
19 return blk_mq_rq_to_pdu(rq);
20}
21
22static inline void scsi_req_free_cmd(struct scsi_request *req)
23{
24 if (req->cmd != req->__cmd)
25 kfree(req->cmd);
26}
27
28void scsi_req_init(struct request *);
29
30#endif /* _SCSI_SCSI_REQUEST_H */
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-03 09:09:40 -0500