History

blk-mq: switch ->queue_rq return value to blk_status_t

Use the same values for use for request completion errors as the return value from ->queue_rq. BLK_STS_RESOURCE is special cased to cause a requeue, and all the others are completed as-is.

Christoph Hellwig committed 9 years ago

Commit fc17b651 parent 2a842ac18 files · +131 −142Browse files

Unified · Split

18 files
  1. block/blk-mq.c +17 −20
  2. drivers/block/loop.c +3 −3
  3. drivers/block/mtip32xx/mtip32xx.c +8 −9
  4. drivers/block/nbd.c +4 −8
  5. drivers/block/null_blk.c +2 −2
  6. drivers/block/rbd.c +2 −2
  7. drivers/block/virtio_blk.c +5 −5
  8. drivers/block/xen-blkfront.c +4 −4
  9. drivers/md/dm-rq.c +4 −4
  10. drivers/mtd/ubi/block.c +3 −3
  11. drivers/nvme/host/core.c +7 −7
  12. drivers/nvme/host/fc.c +12 −11
  13. drivers/nvme/host/nvme.h +1 −1
  14. drivers/nvme/host/pci.c +20 −22
  15. drivers/nvme/host/rdma.c +14 −12
  16. drivers/nvme/target/loop.c +8 −9
  17. drivers/scsi/scsi_lib.c +15 −15
  18. include/linux/blk-mq.h +2 −5
block/blk-mq.c+17−20
@@ -924,7 +924,7 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list) · 923 unmodified lines
924924 {
925925 struct blk_mq_hw_ctx *hctx;
926926 struct request *rq;
927− int errors, queued, ret = BLK_MQ_RQ_QUEUE_OK;
927+ int errors, queued;
928928
929929 if (list_empty(list))
930930 return false;
@@ -935,6 +935,7 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list) · 4 unmodified lines
935935 errors = queued = 0;
936936 do {
937937 struct blk_mq_queue_data bd;
938+ blk_status_t ret;
938939
939940 rq = list_first_entry(list, struct request, queuelist);
940941 if (!blk_mq_get_driver_tag(rq, &hctx, false)) {
@@ -975,25 +976,20 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list) · 34 unmodified lines
975976 }
976977
977978 ret = q->mq_ops->queue_rq(hctx, &bd);
978− switch (ret) {
979− case BLK_MQ_RQ_QUEUE_OK:
980− queued++;
981− break;
982− case BLK_MQ_RQ_QUEUE_BUSY:
979+ if (ret == BLK_STS_RESOURCE) {
983980 blk_mq_put_driver_tag_hctx(hctx, rq);
984981 list_add(&rq->queuelist, list);
985982 __blk_mq_requeue_request(rq);
986983 break;
987− default:
988− pr_err("blk-mq: bad return on queue: %d\n", ret);
989− case BLK_MQ_RQ_QUEUE_ERROR:
984+ }
985+
986+ if (unlikely(ret != BLK_STS_OK)) {
990987 errors++;
991988 blk_mq_end_request(rq, BLK_STS_IOERR);
992− break;
989+ continue;
993990 }
994991
995− if (ret == BLK_MQ_RQ_QUEUE_BUSY)
996− break;
992+ queued++;
997993 } while (!list_empty(list));
998994
999995 hctx->dispatched[queued_to_index(queued)]++;
@@ -1031,7 +1027,7 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list) · 31 unmodified lines
10311027 * - blk_mq_run_hw_queue() checks whether or not a queue has
10321028 * been stopped before rerunning a queue.
10331029 * - Some but not all block drivers stop a queue before
1034− * returning BLK_MQ_RQ_QUEUE_BUSY. Two exceptions are scsi-mq
1030+ * returning BLK_STS_RESOURCE. Two exceptions are scsi-mq
10351031 * and dm-rq.
10361032 */
10371033 if (!blk_mq_sched_needs_restart(hctx) &&
@@ -1410,7 +1406,7 @@ static void __blk_mq_try_issue_directly(struct request *rq, blk_qc_t *cookie, · 372 unmodified lines
14101406 };
14111407 struct blk_mq_hw_ctx *hctx;
14121408 blk_qc_t new_cookie;
1413− int ret;
1409+ blk_status_t ret;
14141410
14151411 if (q->elevator)
14161412 goto insert;
@@ -1426,18 +1422,19 @@ static void __blk_mq_try_issue_directly(struct request *rq, blk_qc_t *cookie, · 9 unmodified lines
14261422 * would have done
14271423 */
14281424 ret = q->mq_ops->queue_rq(hctx, &bd);
1429− if (ret == BLK_MQ_RQ_QUEUE_OK) {
1425+ switch (ret) {
1426+ case BLK_STS_OK:
14301427 *cookie = new_cookie;
14311428 return;
1432− }
1433−
1434− if (ret == BLK_MQ_RQ_QUEUE_ERROR) {
1429+ case BLK_STS_RESOURCE:
1430+ __blk_mq_requeue_request(rq);
1431+ goto insert;
1432+ default:
14351433 *cookie = BLK_QC_T_NONE;
1436− blk_mq_end_request(rq, BLK_STS_IOERR);
1434+ blk_mq_end_request(rq, ret);
14371435 return;
14381436 }
14391437
1440− __blk_mq_requeue_request(rq);
14411438 insert:
14421439 blk_mq_sched_insert_request(rq, false, true, false, may_sleep);
14431440 }
drivers/block/loop.c+3−3
@@ -1674,7 +1674,7 @@ int loop_unregister_transfer(int number) · 1673 unmodified lines
16741674 EXPORT_SYMBOL(loop_register_transfer);
16751675 EXPORT_SYMBOL(loop_unregister_transfer);
16761676
1677−static int loop_queue_rq(struct blk_mq_hw_ctx *hctx,
1677+static blk_status_t loop_queue_rq(struct blk_mq_hw_ctx *hctx,
16781678 const struct blk_mq_queue_data *bd)
16791679 {
16801680 struct loop_cmd *cmd = blk_mq_rq_to_pdu(bd->rq);
@@ -1683,7 +1683,7 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx, · 2 unmodified lines
16831683 blk_mq_start_request(bd->rq);
16841684
16851685 if (lo->lo_state != Lo_bound)
1686− return BLK_MQ_RQ_QUEUE_ERROR;
1686+ return BLK_STS_IOERR;
16871687
16881688 switch (req_op(cmd->rq)) {
16891689 case REQ_OP_FLUSH:
@@ -1698,7 +1698,7 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx, · 8 unmodified lines
16981698
16991699 kthread_queue_work(&lo->worker, &cmd->work);
17001700
1701− return BLK_MQ_RQ_QUEUE_OK;
1701+ return BLK_STS_OK;
17021702 }
17031703
17041704 static void loop_handle_cmd(struct loop_cmd *cmd)
drivers/block/mtip32xx/mtip32xx.c+8−9
@@ -3633,8 +3633,8 @@ static bool mtip_check_unal_depth(struct blk_mq_hw_ctx *hctx, · 3632 unmodified lines
36333633 return false;
36343634 }
36353635
3636−static int mtip_issue_reserved_cmd(struct blk_mq_hw_ctx *hctx,
3637− struct request *rq)
3636+static blk_status_t mtip_issue_reserved_cmd(struct blk_mq_hw_ctx *hctx,
3637+ struct request *rq)
36383638 {
36393639 struct driver_data *dd = hctx->queue->queuedata;
36403640 struct mtip_int_cmd *icmd = rq->special;
@@ -3642,7 +3642,7 @@ static int mtip_issue_reserved_cmd(struct blk_mq_hw_ctx *hctx, · 1 unmodified line
36423642 struct mtip_cmd_sg *command_sg;
36433643
36443644 if (mtip_commands_active(dd->port))
3645− return BLK_MQ_RQ_QUEUE_BUSY;
3645+ return BLK_STS_RESOURCE;
36463646
36473647 /* Populate the SG list */
36483648 cmd->command_header->opts =
@@ -3666,10 +3666,10 @@ static int mtip_issue_reserved_cmd(struct blk_mq_hw_ctx *hctx, · 17 unmodified lines
36663666
36673667 blk_mq_start_request(rq);
36683668 mtip_issue_non_ncq_command(dd->port, rq->tag);
3669− return BLK_MQ_RQ_QUEUE_OK;
3669+ return 0;
36703670 }
36713671
3672−static int mtip_queue_rq(struct blk_mq_hw_ctx *hctx,
3672+static blk_status_t mtip_queue_rq(struct blk_mq_hw_ctx *hctx,
36733673 const struct blk_mq_queue_data *bd)
36743674 {
36753675 struct request *rq = bd->rq;
@@ -3681,15 +3681,14 @@ static int mtip_queue_rq(struct blk_mq_hw_ctx *hctx, · 5 unmodified lines
36813681 return mtip_issue_reserved_cmd(hctx, rq);
36823682
36833683 if (unlikely(mtip_check_unal_depth(hctx, rq)))
3684− return BLK_MQ_RQ_QUEUE_BUSY;
3684+ return BLK_STS_RESOURCE;
36853685
36863686 blk_mq_start_request(rq);
36873687
36883688 ret = mtip_submit_request(hctx, rq);
36893689 if (likely(!ret))
3690− return BLK_MQ_RQ_QUEUE_OK;
3691−
3692− return BLK_MQ_RQ_QUEUE_ERROR;
3690+ return BLK_STS_OK;
3691+ return BLK_STS_IOERR;
36933692 }
36943693
36953694 static void mtip_free_cmd(struct blk_mq_tag_set *set, struct request *rq,
drivers/block/nbd.c+4−8
@@ -469,7 +469,7 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) · 468 unmodified lines
469469 nsock->pending = req;
470470 nsock->sent = sent;
471471 }
472− return BLK_MQ_RQ_QUEUE_BUSY;
472+ return BLK_STS_RESOURCE;
473473 }
474474 dev_err_ratelimited(disk_to_dev(nbd->disk),
475475 "Send control failed (result %d)\n", result);
@@ -510,7 +510,7 @@ send_pages: · 34 unmodified lines
510510 */
511511 nsock->pending = req;
512512 nsock->sent = sent;
513− return BLK_MQ_RQ_QUEUE_BUSY;
513+ return BLK_STS_RESOURCE;
514514 }
515515 dev_err(disk_to_dev(nbd->disk),
516516 "Send data failed (result %d)\n",
@@ -798,7 +798,7 @@ out: · 281 unmodified lines
798798 return ret;
799799 }
800800
801−static int nbd_queue_rq(struct blk_mq_hw_ctx *hctx,
801+static blk_status_t nbd_queue_rq(struct blk_mq_hw_ctx *hctx,
802802 const struct blk_mq_queue_data *bd)
803803 {
804804 struct nbd_cmd *cmd = blk_mq_rq_to_pdu(bd->rq);
@@ -822,13 +822,9 @@ static int nbd_queue_rq(struct blk_mq_hw_ctx *hctx, · 17 unmodified lines
822822 * appropriate.
823823 */
824824 ret = nbd_handle_cmd(cmd, hctx->queue_num);
825− if (ret < 0)
826− ret = BLK_MQ_RQ_QUEUE_ERROR;
827− if (!ret)
828− ret = BLK_MQ_RQ_QUEUE_OK;
829825 complete(&cmd->send_complete);
830826
831− return ret;
827+ return ret < 0 ? BLK_STS_IOERR : BLK_STS_OK;
832828 }
833829
834830 static int nbd_add_socket(struct nbd_device *nbd, unsigned long arg,
drivers/block/null_blk.c+2−2
@@ -356,7 +356,7 @@ static void null_request_fn(struct request_queue *q) · 355 unmodified lines
356356 }
357357 }
358358
359−static int null_queue_rq(struct blk_mq_hw_ctx *hctx,
359+static blk_status_t null_queue_rq(struct blk_mq_hw_ctx *hctx,
360360 const struct blk_mq_queue_data *bd)
361361 {
362362 struct nullb_cmd *cmd = blk_mq_rq_to_pdu(bd->rq);
@@ -373,7 +373,7 @@ static int null_queue_rq(struct blk_mq_hw_ctx *hctx, · 10 unmodified lines
373373 blk_mq_start_request(bd->rq);
374374
375375 null_handle_cmd(cmd);
376− return BLK_MQ_RQ_QUEUE_OK;
376+ return BLK_STS_OK;
377377 }
378378
379379 static void null_init_queue(struct nullb *nullb, struct nullb_queue *nq)
drivers/block/rbd.c+2−2
@@ -4154,14 +4154,14 @@ err: · 4153 unmodified lines
41544154 blk_mq_end_request(rq, errno_to_blk_status(result));
41554155 }
41564156
4157−static int rbd_queue_rq(struct blk_mq_hw_ctx *hctx,
4157+static blk_status_t rbd_queue_rq(struct blk_mq_hw_ctx *hctx,
41584158 const struct blk_mq_queue_data *bd)
41594159 {
41604160 struct request *rq = bd->rq;
41614161 struct work_struct *work = blk_mq_rq_to_pdu(rq);
41624162
41634163 queue_work(rbd_wq, work);
4164− return BLK_MQ_RQ_QUEUE_OK;
4164+ return BLK_STS_OK;
41654165 }
41664166
41674167 static void rbd_free_disk(struct rbd_device *rbd_dev)
drivers/block/virtio_blk.c+5−5
@@ -214,7 +214,7 @@ static void virtblk_done(struct virtqueue *vq) · 213 unmodified lines
214214 spin_unlock_irqrestore(&vblk->vqs[qid].lock, flags);
215215 }
216216
217−static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx,
217+static blk_status_t virtio_queue_rq(struct blk_mq_hw_ctx *hctx,
218218 const struct blk_mq_queue_data *bd)
219219 {
220220 struct virtio_blk *vblk = hctx->queue->queuedata;
@@ -246,7 +246,7 @@ static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx, · 25 unmodified lines
246246 break;
247247 default:
248248 WARN_ON_ONCE(1);
249− return BLK_MQ_RQ_QUEUE_ERROR;
249+ return BLK_STS_IOERR;
250250 }
251251
252252 vbr->out_hdr.type = cpu_to_virtio32(vblk->vdev, type);
@@ -276,8 +276,8 @@ static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx, · 23 unmodified lines
276276 /* Out of mem doesn't actually happen, since we fall back
277277 * to direct descriptors */
278278 if (err == -ENOMEM || err == -ENOSPC)
279− return BLK_MQ_RQ_QUEUE_BUSY;
280− return BLK_MQ_RQ_QUEUE_ERROR;
279+ return BLK_STS_RESOURCE;
280+ return BLK_STS_IOERR;
281281 }
282282
283283 if (bd->last && virtqueue_kick_prepare(vblk->vqs[qid].vq))
@@ -286,7 +286,7 @@ static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx, · 2 unmodified lines
286286
287287 if (notify)
288288 virtqueue_notify(vblk->vqs[qid].vq);
289− return BLK_MQ_RQ_QUEUE_OK;
289+ return BLK_STS_OK;
290290 }
291291
292292 /* return id (s/n) string for *disk to *id_str
drivers/block/xen-blkfront.c+4−4
@@ -881,7 +881,7 @@ static inline bool blkif_request_flush_invalid(struct request *req, · 880 unmodified lines
881881 !info->feature_fua));
882882 }
883883
884−static int blkif_queue_rq(struct blk_mq_hw_ctx *hctx,
884+static blk_status_t blkif_queue_rq(struct blk_mq_hw_ctx *hctx,
885885 const struct blk_mq_queue_data *qd)
886886 {
887887 unsigned long flags;
@@ -904,16 +904,16 @@ static int blkif_queue_rq(struct blk_mq_hw_ctx *hctx, · 16 unmodified lines
904904
905905 flush_requests(rinfo);
906906 spin_unlock_irqrestore(&rinfo->ring_lock, flags);
907− return BLK_MQ_RQ_QUEUE_OK;
907+ return BLK_STS_OK;
908908
909909 out_err:
910910 spin_unlock_irqrestore(&rinfo->ring_lock, flags);
911− return BLK_MQ_RQ_QUEUE_ERROR;
911+ return BLK_STS_IOERR;
912912
913913 out_busy:
914914 spin_unlock_irqrestore(&rinfo->ring_lock, flags);
915915 blk_mq_stop_hw_queue(hctx);
916− return BLK_MQ_RQ_QUEUE_BUSY;
916+ return BLK_STS_RESOURCE;
917917 }
918918
919919 static void blkif_complete_rq(struct request *rq)
drivers/md/dm-rq.c+4−4
@@ -727,7 +727,7 @@ static int dm_mq_init_request(struct blk_mq_tag_set *set, struct request *rq, · 726 unmodified lines
727727 return __dm_rq_init_rq(set->driver_data, rq);
728728 }
729729
730−static int dm_mq_queue_rq(struct blk_mq_hw_ctx *hctx,
730+static blk_status_t dm_mq_queue_rq(struct blk_mq_hw_ctx *hctx,
731731 const struct blk_mq_queue_data *bd)
732732 {
733733 struct request *rq = bd->rq;
@@ -744,7 +744,7 @@ static int dm_mq_queue_rq(struct blk_mq_hw_ctx *hctx, · 10 unmodified lines
744744 }
745745
746746 if (ti->type->busy && ti->type->busy(ti))
747− return BLK_MQ_RQ_QUEUE_BUSY;
747+ return BLK_STS_RESOURCE;
748748
749749 dm_start_request(md, rq);
750750
@@ -762,10 +762,10 @@ static int dm_mq_queue_rq(struct blk_mq_hw_ctx *hctx, · 11 unmodified lines
762762 rq_end_stats(md, rq);
763763 rq_completed(md, rq_data_dir(rq), false);
764764 blk_mq_delay_run_hw_queue(hctx, 100/*ms*/);
765− return BLK_MQ_RQ_QUEUE_BUSY;
765+ return BLK_STS_RESOURCE;
766766 }
767767
768− return BLK_MQ_RQ_QUEUE_OK;
768+ return BLK_STS_OK;
769769 }
770770
771771 static const struct blk_mq_ops dm_mq_ops = {
drivers/mtd/ubi/block.c+3−3
@@ -316,7 +316,7 @@ static void ubiblock_do_work(struct work_struct *work) · 315 unmodified lines
316316 blk_mq_end_request(req, errno_to_blk_status(ret));
317317 }
318318
319−static int ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
319+static blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
320320 const struct blk_mq_queue_data *bd)
321321 {
322322 struct request *req = bd->rq;
@@ -327,9 +327,9 @@ static int ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx, · 4 unmodified lines
327327 case REQ_OP_READ:
328328 ubi_sgl_init(&pdu->usgl);
329329 queue_work(dev->wq, &pdu->work);
330− return BLK_MQ_RQ_QUEUE_OK;
330+ return BLK_STS_OK;
331331 default:
332− return BLK_MQ_RQ_QUEUE_ERROR;
332+ return BLK_STS_IOERR;
333333 }
334334
335335 }
drivers/nvme/host/core.c+7−7
@@ -283,7 +283,7 @@ static inline void nvme_setup_flush(struct nvme_ns *ns, · 282 unmodified lines
283283 cmnd->common.nsid = cpu_to_le32(ns->ns_id);
284284 }
285285
286−static inline int nvme_setup_discard(struct nvme_ns *ns, struct request *req,
286+static blk_status_t nvme_setup_discard(struct nvme_ns *ns, struct request *req,
287287 struct nvme_command *cmnd)
288288 {
289289 unsigned short segments = blk_rq_nr_discard_segments(req), n = 0;
@@ -292,7 +292,7 @@ static inline int nvme_setup_discard(struct nvme_ns *ns, struct request *req, · 2 unmodified lines
292292
293293 range = kmalloc_array(segments, sizeof(*range), GFP_ATOMIC);
294294 if (!range)
295− return BLK_MQ_RQ_QUEUE_BUSY;
295+ return BLK_STS_RESOURCE;
296296
297297 __rq_for_each_bio(bio, req) {
298298 u64 slba = nvme_block_nr(ns, bio->bi_iter.bi_sector);
@@ -306,7 +306,7 @@ static inline int nvme_setup_discard(struct nvme_ns *ns, struct request *req, · 7 unmodified lines
306306
307307 if (WARN_ON_ONCE(n != segments)) {
308308 kfree(range);
309− return BLK_MQ_RQ_QUEUE_ERROR;
309+ return BLK_STS_IOERR;
310310 }
311311
312312 memset(cmnd, 0, sizeof(*cmnd));
@@ -320,7 +320,7 @@ static inline int nvme_setup_discard(struct nvme_ns *ns, struct request *req, · 7 unmodified lines
320320 req->special_vec.bv_len = sizeof(*range) * segments;
321321 req->rq_flags |= RQF_SPECIAL_PAYLOAD;
322322
323− return BLK_MQ_RQ_QUEUE_OK;
323+ return BLK_STS_OK;
324324 }
325325
326326 static inline void nvme_setup_rw(struct nvme_ns *ns, struct request *req,
@@ -364,10 +364,10 @@ static inline void nvme_setup_rw(struct nvme_ns *ns, struct request *req, · 37 unmodified lines
364364 cmnd->rw.dsmgmt = cpu_to_le32(dsmgmt);
365365 }
366366
367−int nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
367+blk_status_t nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
368368 struct nvme_command *cmd)
369369 {
370− int ret = BLK_MQ_RQ_QUEUE_OK;
370+ blk_status_t ret = BLK_STS_OK;
371371
372372 if (!(req->rq_flags & RQF_DONTPREP)) {
373373 nvme_req(req)->retries = 0;
@@ -394,7 +394,7 @@ int nvme_setup_cmd(struct nvme_ns *ns, struct request *req, · 20 unmodified lines
394394 break;
395395 default:
396396 WARN_ON_ONCE(1);
397− return BLK_MQ_RQ_QUEUE_ERROR;
397+ return BLK_STS_IOERR;
398398 }
399399
400400 cmd->common.command_id = req->tag;
drivers/nvme/host/fc.c+12−11
@@ -1873,7 +1873,7 @@ nvme_fc_unmap_data(struct nvme_fc_ctrl *ctrl, struct request *rq, · 1872 unmodified lines
18731873 * level FC exchange resource that is also outstanding. This must be
18741874 * considered in all cleanup operations.
18751875 */
1876−static int
1876+static blk_status_t
18771877 nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,
18781878 struct nvme_fc_fcp_op *op, u32 data_len,
18791879 enum nvmefc_fcp_datadir io_dir)
@@ -1888,10 +1888,10 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue, · 8 unmodified lines
18881888 * the target device is present
18891889 */
18901890 if (ctrl->rport->remoteport.port_state != FC_OBJSTATE_ONLINE)
1891− return BLK_MQ_RQ_QUEUE_ERROR;
1891+ return BLK_STS_IOERR;
18921892
18931893 if (!nvme_fc_ctrl_get(ctrl))
1894− return BLK_MQ_RQ_QUEUE_ERROR;
1894+ return BLK_STS_IOERR;
18951895
18961896 /* format the FC-NVME CMD IU and fcp_req */
18971897 cmdiu->connection_id = cpu_to_be64(queue->connection_id);
@@ -1939,8 +1939,9 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue, · 41 unmodified lines
19391939 if (ret < 0) {
19401940 nvme_cleanup_cmd(op->rq);
19411941 nvme_fc_ctrl_put(ctrl);
1942− return (ret == -ENOMEM || ret == -EAGAIN) ?
1943− BLK_MQ_RQ_QUEUE_BUSY : BLK_MQ_RQ_QUEUE_ERROR;
1942+ if (ret == -ENOMEM || ret == -EAGAIN)
1943+ return BLK_STS_RESOURCE;
1944+ return BLK_STS_IOERR;
19441945 }
19451946 }
19461947
@@ -1966,19 +1967,19 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue, · 19 unmodified lines
19661967 nvme_fc_ctrl_put(ctrl);
19671968
19681969 if (ret != -EBUSY)
1969− return BLK_MQ_RQ_QUEUE_ERROR;
1970+ return BLK_STS_IOERR;
19701971
19711972 if (op->rq) {
19721973 blk_mq_stop_hw_queues(op->rq->q);
19731974 blk_mq_delay_queue(queue->hctx, NVMEFC_QUEUE_DELAY);
19741975 }
1975− return BLK_MQ_RQ_QUEUE_BUSY;
1976+ return BLK_STS_RESOURCE;
19761977 }
19771978
1978− return BLK_MQ_RQ_QUEUE_OK;
1979+ return BLK_STS_OK;
19791980 }
19801981
1981−static int
1982+static blk_status_t
19821983 nvme_fc_queue_rq(struct blk_mq_hw_ctx *hctx,
19831984 const struct blk_mq_queue_data *bd)
19841985 {
@@ -1991,7 +1992,7 @@ nvme_fc_queue_rq(struct blk_mq_hw_ctx *hctx, · 6 unmodified lines
19911992 struct nvme_command *sqe = &cmdiu->sqe;
19921993 enum nvmefc_fcp_datadir io_dir;
19931994 u32 data_len;
1994− int ret;
1995+ blk_status_t ret;
19951996
19961997 ret = nvme_setup_cmd(ns, rq, sqe);
19971998 if (ret)
@@ -2046,7 +2047,7 @@ nvme_fc_submit_async_event(struct nvme_ctrl *arg, int aer_idx) · 48 unmodified lines
20462047 struct nvme_fc_fcp_op *aen_op;
20472048 unsigned long flags;
20482049 bool terminating = false;
2049− int ret;
2050+ blk_status_t ret;
20502051
20512052 if (aer_idx > NVME_FC_NR_AEN_COMMANDS)
20522053 return;
drivers/nvme/host/nvme.h+1−1
@@ -296,7 +296,7 @@ void nvme_start_freeze(struct nvme_ctrl *ctrl); · 295 unmodified lines
296296 #define NVME_QID_ANY -1
297297 struct request *nvme_alloc_request(struct request_queue *q,
298298 struct nvme_command *cmd, unsigned int flags, int qid);
299−int nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
299+blk_status_t nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
300300 struct nvme_command *cmd);
301301 int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
302302 void *buf, unsigned bufflen);
drivers/nvme/host/pci.c+20−22
@@ -427,7 +427,7 @@ static __le64 **iod_list(struct request *req) · 426 unmodified lines
427427 return (__le64 **)(iod->sg + blk_rq_nr_phys_segments(req));
428428 }
429429
430−static int nvme_init_iod(struct request *rq, struct nvme_dev *dev)
430+static blk_status_t nvme_init_iod(struct request *rq, struct nvme_dev *dev)
431431 {
432432 struct nvme_iod *iod = blk_mq_rq_to_pdu(rq);
433433 int nseg = blk_rq_nr_phys_segments(rq);
@@ -436,7 +436,7 @@ static int nvme_init_iod(struct request *rq, struct nvme_dev *dev) · 2 unmodified lines
436436 if (nseg > NVME_INT_PAGES || size > NVME_INT_BYTES(dev)) {
437437 iod->sg = kmalloc(nvme_iod_alloc_size(dev, size, nseg), GFP_ATOMIC);
438438 if (!iod->sg)
439− return BLK_MQ_RQ_QUEUE_BUSY;
439+ return BLK_STS_RESOURCE;
440440 } else {
441441 iod->sg = iod->inline_sg;
442442 }
@@ -446,7 +446,7 @@ static int nvme_init_iod(struct request *rq, struct nvme_dev *dev) · 3 unmodified lines
446446 iod->nents = 0;
447447 iod->length = size;
448448
449− return BLK_MQ_RQ_QUEUE_OK;
449+ return BLK_STS_OK;
450450 }
451451
452452 static void nvme_free_iod(struct nvme_dev *dev, struct request *req)
@@ -616,21 +616,21 @@ static bool nvme_setup_prps(struct nvme_dev *dev, struct request *req) · 163 unmodified lines
616616 return true;
617617 }
618618
619−static int nvme_map_data(struct nvme_dev *dev, struct request *req,
619+static blk_status_t nvme_map_data(struct nvme_dev *dev, struct request *req,
620620 struct nvme_command *cmnd)
621621 {
622622 struct nvme_iod *iod = blk_mq_rq_to_pdu(req);
623623 struct request_queue *q = req->q;
624624 enum dma_data_direction dma_dir = rq_data_dir(req) ?
625625 DMA_TO_DEVICE : DMA_FROM_DEVICE;
626− int ret = BLK_MQ_RQ_QUEUE_ERROR;
626+ blk_status_t ret = BLK_STS_IOERR;
627627
628628 sg_init_table(iod->sg, blk_rq_nr_phys_segments(req));
629629 iod->nents = blk_rq_map_sg(q, req, iod->sg);
630630 if (!iod->nents)
631631 goto out;
632632
633− ret = BLK_MQ_RQ_QUEUE_BUSY;
633+ ret = BLK_STS_RESOURCE;
634634 if (!dma_map_sg_attrs(dev->dev, iod->sg, iod->nents, dma_dir,
635635 DMA_ATTR_NO_WARN))
636636 goto out;
@@ -638,7 +638,7 @@ static int nvme_map_data(struct nvme_dev *dev, struct request *req, · 1 unmodified line
638638 if (!nvme_setup_prps(dev, req))
639639 goto out_unmap;
640640
641− ret = BLK_MQ_RQ_QUEUE_ERROR;
641+ ret = BLK_STS_IOERR;
642642 if (blk_integrity_rq(req)) {
643643 if (blk_rq_count_integrity_sg(q, req->bio) != 1)
644644 goto out_unmap;
@@ -658,7 +658,7 @@ static int nvme_map_data(struct nvme_dev *dev, struct request *req, · 13 unmodified lines
658658 cmnd->rw.dptr.prp2 = cpu_to_le64(iod->first_dma);
659659 if (blk_integrity_rq(req))
660660 cmnd->rw.metadata = cpu_to_le64(sg_dma_address(&iod->meta_sg));
661− return BLK_MQ_RQ_QUEUE_OK;
661+ return BLK_STS_OK;
662662
663663 out_unmap:
664664 dma_unmap_sg(dev->dev, iod->sg, iod->nents, dma_dir);
@@ -688,7 +688,7 @@ static void nvme_unmap_data(struct nvme_dev *dev, struct request *req) · 23 unmodified lines
688688 /*
689689 * NOTE: ns is NULL when called on the admin queue.
690690 */
691−static int nvme_queue_rq(struct blk_mq_hw_ctx *hctx,
691+static blk_status_t nvme_queue_rq(struct blk_mq_hw_ctx *hctx,
692692 const struct blk_mq_queue_data *bd)
693693 {
694694 struct nvme_ns *ns = hctx->queue->queuedata;
@@ -696,7 +696,7 @@ static int nvme_queue_rq(struct blk_mq_hw_ctx *hctx, · 1 unmodified line
696696 struct nvme_dev *dev = nvmeq->dev;
697697 struct request *req = bd->rq;
698698 struct nvme_command cmnd;
699− int ret = BLK_MQ_RQ_QUEUE_OK;
699+ blk_status_t ret = BLK_STS_OK;
700700
701701 /*
702702 * If formated with metadata, require the block layer provide a buffer
@@ -705,38 +705,36 @@ static int nvme_queue_rq(struct blk_mq_hw_ctx *hctx, · 2 unmodified lines
705705 */
706706 if (ns && ns->ms && !blk_integrity_rq(req)) {
707707 if (!(ns->pi_type && ns->ms == 8) &&
708− !blk_rq_is_passthrough(req)) {
709− blk_mq_end_request(req, BLK_STS_NOTSUPP);
710− return BLK_MQ_RQ_QUEUE_OK;
711− }
708+ !blk_rq_is_passthrough(req))
709+ return BLK_STS_NOTSUPP;
712710 }
713711
714712 ret = nvme_setup_cmd(ns, req, &cmnd);
715− if (ret != BLK_MQ_RQ_QUEUE_OK)
713+ if (ret)
716714 return ret;
717715
718716 ret = nvme_init_iod(req, dev);
719− if (ret != BLK_MQ_RQ_QUEUE_OK)
717+ if (ret)
720718 goto out_free_cmd;
721719
722− if (blk_rq_nr_phys_segments(req))
720+ if (blk_rq_nr_phys_segments(req)) {
723721 ret = nvme_map_data(dev, req, &cmnd);
724−
725− if (ret != BLK_MQ_RQ_QUEUE_OK)
726− goto out_cleanup_iod;
722+ if (ret)
723+ goto out_cleanup_iod;
724+ }
727725
728726 blk_mq_start_request(req);
729727
730728 spin_lock_irq(&nvmeq->q_lock);
731729 if (unlikely(nvmeq->cq_vector < 0)) {
732− ret = BLK_MQ_RQ_QUEUE_ERROR;
730+ ret = BLK_STS_IOERR;
733731 spin_unlock_irq(&nvmeq->q_lock);
734732 goto out_cleanup_iod;
735733 }
736734 __nvme_submit_cmd(nvmeq, &cmnd);
737735 nvme_process_cq(nvmeq);
738736 spin_unlock_irq(&nvmeq->q_lock);
739− return BLK_MQ_RQ_QUEUE_OK;
737+ return BLK_STS_OK;
740738 out_cleanup_iod:
741739 nvme_free_iod(dev, req);
742740 out_free_cmd:
drivers/nvme/host/rdma.c+14−12
@@ -1448,7 +1448,7 @@ static inline bool nvme_rdma_queue_is_ready(struct nvme_rdma_queue *queue, · 1447 unmodified lines
14481448 return true;
14491449 }
14501450
1451−static int nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,
1451+static blk_status_t nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,
14521452 const struct blk_mq_queue_data *bd)
14531453 {
14541454 struct nvme_ns *ns = hctx->queue->queuedata;
@@ -1459,27 +1459,28 @@ static int nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx, · 4 unmodified lines
14591459 struct nvme_command *c = sqe->data;
14601460 bool flush = false;
14611461 struct ib_device *dev;
1462− int ret;
1462+ blk_status_t ret;
1463+ int err;
14631464
14641465 WARN_ON_ONCE(rq->tag < 0);
14651466
14661467 if (!nvme_rdma_queue_is_ready(queue, rq))
1467− return BLK_MQ_RQ_QUEUE_BUSY;
1468+ return BLK_STS_RESOURCE;
14681469
14691470 dev = queue->device->dev;
14701471 ib_dma_sync_single_for_cpu(dev, sqe->dma,
14711472 sizeof(struct nvme_command), DMA_TO_DEVICE);
14721473
14731474 ret = nvme_setup_cmd(ns, rq, c);
1474− if (ret != BLK_MQ_RQ_QUEUE_OK)
1475+ if (ret)
14751476 return ret;
14761477
14771478 blk_mq_start_request(rq);
14781479
1479− ret = nvme_rdma_map_data(queue, rq, c);
1480− if (ret < 0) {
1480+ err = nvme_rdma_map_data(queue, rq, c);
1481+ if (err < 0) {
14811482 dev_err(queue->ctrl->ctrl.device,
1482− "Failed to map data (%d)\n", ret);
1483+ "Failed to map data (%d)\n", err);
14831484 nvme_cleanup_cmd(rq);
14841485 goto err;
14851486 }
@@ -1489,17 +1490,18 @@ static int nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx, · 3 unmodified lines
14891490
14901491 if (req_op(rq) == REQ_OP_FLUSH)
14911492 flush = true;
1492− ret = nvme_rdma_post_send(queue, sqe, req->sge, req->num_sge,
1493+ err = nvme_rdma_post_send(queue, sqe, req->sge, req->num_sge,
14931494 req->mr->need_inval ? &req->reg_wr.wr : NULL, flush);
1494− if (ret) {
1495+ if (err) {
14951496 nvme_rdma_unmap_data(queue, rq);
14961497 goto err;
14971498 }
14981499
1499− return BLK_MQ_RQ_QUEUE_OK;
1500+ return BLK_STS_OK;
15001501 err:
1501− return (ret == -ENOMEM || ret == -EAGAIN) ?
1502− BLK_MQ_RQ_QUEUE_BUSY : BLK_MQ_RQ_QUEUE_ERROR;
1502+ if (err == -ENOMEM || err == -EAGAIN)
1503+ return BLK_STS_RESOURCE;
1504+ return BLK_STS_IOERR;
15031505 }
15041506
15051507 static int nvme_rdma_poll(struct blk_mq_hw_ctx *hctx, unsigned int tag)
drivers/nvme/target/loop.c+8−9
@@ -159,17 +159,17 @@ nvme_loop_timeout(struct request *rq, bool reserved) · 158 unmodified lines
159159 return BLK_EH_HANDLED;
160160 }
161161
162−static int nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx,
162+static blk_status_t nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx,
163163 const struct blk_mq_queue_data *bd)
164164 {
165165 struct nvme_ns *ns = hctx->queue->queuedata;
166166 struct nvme_loop_queue *queue = hctx->driver_data;
167167 struct request *req = bd->rq;
168168 struct nvme_loop_iod *iod = blk_mq_rq_to_pdu(req);
169− int ret;
169+ blk_status_t ret;
170170
171171 ret = nvme_setup_cmd(ns, req, &iod->cmd);
172− if (ret != BLK_MQ_RQ_QUEUE_OK)
172+ if (ret)
173173 return ret;
174174
175175 iod->cmd.common.flags |= NVME_CMD_SGL_METABUF;
@@ -179,16 +179,15 @@ static int nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx, · 3 unmodified lines
179179 nvme_cleanup_cmd(req);
180180 blk_mq_start_request(req);
181181 nvme_loop_queue_response(&iod->req);
182− return BLK_MQ_RQ_QUEUE_OK;
182+ return BLK_STS_OK;
183183 }
184184
185185 if (blk_rq_bytes(req)) {
186186 iod->sg_table.sgl = iod->first_sgl;
187− ret = sg_alloc_table_chained(&iod->sg_table,
187+ if (sg_alloc_table_chained(&iod->sg_table,
188188 blk_rq_nr_phys_segments(req),
189− iod->sg_table.sgl);
190− if (ret)
191− return BLK_MQ_RQ_QUEUE_BUSY;
189+ iod->sg_table.sgl))
190+ return BLK_STS_RESOURCE;
192191
193192 iod->req.sg = iod->sg_table.sgl;
194193 iod->req.sg_cnt = blk_rq_map_sg(req->q, req, iod->sg_table.sgl);
@@ -197,7 +196,7 @@ static int nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx, · 2 unmodified lines
197196 blk_mq_start_request(req);
198197
199198 schedule_work(&iod->work);
200− return BLK_MQ_RQ_QUEUE_OK;
199+ return BLK_STS_OK;
201200 }
202201
203202 static void nvme_loop_submit_async_event(struct nvme_ctrl *arg, int aer_idx)
drivers/scsi/scsi_lib.c+15−15
@@ -1812,15 +1812,15 @@ out_delay: · 1811 unmodified lines
18121812 blk_delay_queue(q, SCSI_QUEUE_DELAY);
18131813 }
18141814
1815−static inline int prep_to_mq(int ret)
1815+static inline blk_status_t prep_to_mq(int ret)
18161816 {
18171817 switch (ret) {
18181818 case BLKPREP_OK:
1819− return BLK_MQ_RQ_QUEUE_OK;
1819+ return BLK_STS_OK;
18201820 case BLKPREP_DEFER:
1821− return BLK_MQ_RQ_QUEUE_BUSY;
1821+ return BLK_STS_RESOURCE;
18221822 default:
1823− return BLK_MQ_RQ_QUEUE_ERROR;
1823+ return BLK_STS_IOERR;
18241824 }
18251825 }
18261826
@@ -1892,7 +1892,7 @@ static void scsi_mq_done(struct scsi_cmnd *cmd) · 65 unmodified lines
18921892 blk_mq_complete_request(cmd->request);
18931893 }
18941894
1895−static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
1895+static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
18961896 const struct blk_mq_queue_data *bd)
18971897 {
18981898 struct request *req = bd->rq;
@@ -1900,14 +1900,14 @@ static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, · 1 unmodified line
19001900 struct scsi_device *sdev = q->queuedata;
19011901 struct Scsi_Host *shost = sdev->host;
19021902 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
1903− int ret;
1903+ blk_status_t ret;
19041904 int reason;
19051905
19061906 ret = prep_to_mq(scsi_prep_state_check(sdev, req));
1907− if (ret != BLK_MQ_RQ_QUEUE_OK)
1907+ if (ret != BLK_STS_OK)
19081908 goto out;
19091909
1910− ret = BLK_MQ_RQ_QUEUE_BUSY;
1910+ ret = BLK_STS_RESOURCE;
19111911 if (!get_device(&sdev->sdev_gendev))
19121912 goto out;
19131913
@@ -1920,7 +1920,7 @@ static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, · 6 unmodified lines
19201920
19211921 if (!(req->rq_flags & RQF_DONTPREP)) {
19221922 ret = prep_to_mq(scsi_mq_prep_fn(req));
1923− if (ret != BLK_MQ_RQ_QUEUE_OK)
1923+ if (ret != BLK_STS_OK)
19241924 goto out_dec_host_busy;
19251925 req->rq_flags |= RQF_DONTPREP;
19261926 } else {
@@ -1938,11 +1938,11 @@ static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, · 11 unmodified lines
19381938 reason = scsi_dispatch_cmd(cmd);
19391939 if (reason) {
19401940 scsi_set_blocked(cmd, reason);
1941− ret = BLK_MQ_RQ_QUEUE_BUSY;
1941+ ret = BLK_STS_RESOURCE;
19421942 goto out_dec_host_busy;
19431943 }
19441944
1945− return BLK_MQ_RQ_QUEUE_OK;
1945+ return BLK_STS_OK;
19461946
19471947 out_dec_host_busy:
19481948 atomic_dec(&shost->host_busy);
@@ -1955,12 +1955,14 @@ out_put_device: · 6 unmodified lines
19551955 put_device(&sdev->sdev_gendev);
19561956 out:
19571957 switch (ret) {
1958− case BLK_MQ_RQ_QUEUE_BUSY:
1958+ case BLK_STS_OK:
1959+ break;
1960+ case BLK_STS_RESOURCE:
19591961 if (atomic_read(&sdev->device_busy) == 0 &&
19601962 !scsi_device_blocked(sdev))
19611963 blk_mq_delay_run_hw_queue(hctx, SCSI_QUEUE_DELAY);
19621964 break;
1963− case BLK_MQ_RQ_QUEUE_ERROR:
1965+ default:
19641966 /*
19651967 * Make sure to release all allocated ressources when
19661968 * we hit an error, as we will never see this command
@@ -1969,8 +1971,6 @@ out: · 2 unmodified lines
19691971 if (req->rq_flags & RQF_DONTPREP)
19701972 scsi_mq_uninit_cmd(cmd);
19711973 break;
1972− default:
1973− break;
19741974 }
19751975 return ret;
19761976 }
include/linux/blk-mq.h+2−5
@@ -87,7 +87,8 @@ struct blk_mq_queue_data { · 86 unmodified lines
8787 bool last;
8888 };
8989
90−typedef int (queue_rq_fn)(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *);
90+typedef blk_status_t (queue_rq_fn)(struct blk_mq_hw_ctx *,
91+ const struct blk_mq_queue_data *);
9192 typedef enum blk_eh_timer_return (timeout_fn)(struct request *, bool);
9293 typedef int (init_hctx_fn)(struct blk_mq_hw_ctx *, void *, unsigned int);
9394 typedef void (exit_hctx_fn)(struct blk_mq_hw_ctx *, unsigned int);
@@ -155,10 +156,6 @@ struct blk_mq_ops { · 61 unmodified lines
155156 };
156157
157158 enum {
158− BLK_MQ_RQ_QUEUE_OK = 0, /* queued fine */
159− BLK_MQ_RQ_QUEUE_BUSY = 1, /* requeue IO for later */
160− BLK_MQ_RQ_QUEUE_ERROR = 2, /* end IO with error */
161−
162159 BLK_MQ_F_SHOULD_MERGE = 1 << 0,
163160 BLK_MQ_F_TAG_SHARED = 1 << 1,
164161 BLK_MQ_F_SG_MERGE = 1 << 2,

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t