drivers: block,scsi: fixup blk_get_request dead queue scenarios
Rajath Shetty [Thu, 3 Mar 2016 01:29:31 +0000 (17:29 -0800)]
The blk_get_request function may fail in low-memory conditions or during
device removal (even if __GFP_WAIT is set). To distinguish between these
errors, modify the blk_get_request call stack to return the appropriate
ERR_PTR. Verify that all callers check the return status and consider
IS_ERR instead of a simple NULL pointer check.

For consistency, make a similar change to the blk_mq_alloc_request leg
of blk_get_request.  It may fail if the queue is dead, or the caller was
unwilling to wait.

This Change is part of the upstream patch:
a492f075450f3ba87de36e5ffe92a9d0c7af9723

Orignal author: Joe Lawrence <joe.lawrence@stratus.com>

Change-Id: I1da5bc8419f43704e87625dac00c8fc4b88db743
Signed-off-by: Rajath Shetty <rshetty@nvidia.com>
Reviewed-on: http://git-master/r/1022949
GVS: Gerrit_Virtual_Submit
Reviewed-by: Vinayak Pane <vpane@nvidia.com>
Tested-by: Vinayak Pane <vpane@nvidia.com>

18 files changed:
block/blk-core.c
block/bsg.c
block/scsi_ioctl.c
drivers/block/paride/pd.c
drivers/block/pktcdvd.c
drivers/block/sx8.c
drivers/cdrom/cdrom.c
drivers/ide/ide-park.c
drivers/scsi/device_handler/scsi_dh_alua.c
drivers/scsi/device_handler/scsi_dh_emc.c
drivers/scsi/device_handler/scsi_dh_hp_sw.c
drivers/scsi/device_handler/scsi_dh_rdac.c
drivers/scsi/osd/osd_initiator.c
drivers/scsi/osst.c
drivers/scsi/scsi_error.c
drivers/scsi/sg.c
drivers/scsi/st.c
drivers/target/target_core_pscsi.c

index 5a750b1..33aa8c9 100644 (file)
@@ -898,8 +898,8 @@ static struct io_context *rq_ioc(struct bio *bio)
  * pressure or if @q is dead.
  *
  * Must be callled with @q->queue_lock held and,
- * Returns %NULL on failure, with @q->queue_lock held.
- * Returns !%NULL on success, with @q->queue_lock *not held*.
+ * Returns ERR_PTR on failure, with @q->queue_lock held.
+ * Returns request pointer on success, with @q->queue_lock *not held*.
  */
 static struct request *__get_request(struct request_list *rl, int rw_flags,
                                     struct bio *bio, gfp_t gfp_mask)
@@ -913,7 +913,7 @@ static struct request *__get_request(struct request_list *rl, int rw_flags,
        int may_queue;
 
        if (unlikely(blk_queue_dying(q)))
-               return NULL;
+               return ERR_PTR(-ENODEV);
 
        may_queue = elv_may_queue(q, rw_flags);
        if (may_queue == ELV_MQUEUE_NO)
@@ -938,7 +938,7 @@ static struct request *__get_request(struct request_list *rl, int rw_flags,
                                         * process is not a "batcher", and not
                                         * exempted by the IO scheduler
                                         */
-                                       return NULL;
+                                       return ERR_PTR(-ENOMEM);
                                }
                        }
                }
@@ -956,7 +956,7 @@ static struct request *__get_request(struct request_list *rl, int rw_flags,
         * allocated with any setting of ->nr_requests
         */
        if (rl->count[is_sync] >= (3 * q->nr_requests / 2))
-               return NULL;
+               return ERR_PTR(-ENOMEM);
 
        q->nr_rqs[is_sync]++;
        rl->count[is_sync]++;
@@ -1061,7 +1061,7 @@ fail_alloc:
 rq_starved:
        if (unlikely(rl->count[is_sync] == 0))
                rl->starved[is_sync] = 1;
-       return NULL;
+       return ERR_PTR(-ENOMEM);
 }
 
 /**
@@ -1075,8 +1075,8 @@ rq_starved:
  * function keeps retrying under memory pressure and fails iff @q is dead.
  *
  * Must be callled with @q->queue_lock held and,
- * Returns %NULL on failure, with @q->queue_lock held.
- * Returns !%NULL on success, with @q->queue_lock *not held*.
+ * Returns ERR_PTR on failure, with @q->queue_lock held.
+ * Returns request pointer on success, with @q->queue_lock *not held*.
  */
 static struct request *get_request(struct request_queue *q, int rw_flags,
                                   struct bio *bio, gfp_t gfp_mask)
@@ -1089,12 +1089,12 @@ static struct request *get_request(struct request_queue *q, int rw_flags,
        rl = blk_get_rl(q, bio);        /* transferred to @rq on success */
 retry:
        rq = __get_request(rl, rw_flags, bio, gfp_mask);
-       if (rq)
+       if (!IS_ERR(rq))
                return rq;
 
        if (!(gfp_mask & __GFP_WAIT) || unlikely(blk_queue_dying(q))) {
                blk_put_rl(rl);
-               return NULL;
+               return rq;
        }
 
        /* wait on @rl and retry */
@@ -1130,7 +1130,7 @@ struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)
 
        spin_lock_irq(q->queue_lock);
        rq = get_request(q, rw, NULL, gfp_mask);
-       if (!rq)
+       if (IS_ERR(rq))
                spin_unlock_irq(q->queue_lock);
        /* q->queue_lock is unlocked at this point */
 
@@ -1174,8 +1174,8 @@ struct request *blk_make_request(struct request_queue *q, struct bio *bio,
 {
        struct request *rq = blk_get_request(q, bio_data_dir(bio), gfp_mask);
 
-       if (unlikely(!rq))
-               return ERR_PTR(-ENOMEM);
+       if (IS_ERR(rq))
+               return rq;
 
        for_each_bio(bio) {
                struct bio *bounce_bio = bio;
@@ -1539,8 +1539,8 @@ get_rq:
         * Returns with the queue unlocked.
         */
        req = get_request(q, rw_flags, bio, GFP_NOIO);
-       if (unlikely(!req)) {
-               bio_endio(bio, -ENODEV);        /* @q is dead */
+       if (IS_ERR(req)) {
+               bio_endio(bio, PTR_ERR(req));   /* @q is dead */
                goto out_unlock;
        }
 
index 420a5a9..50545e9 100644 (file)
@@ -271,8 +271,8 @@ bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,
         * map scatter-gather elements separately and string them to request
         */
        rq = blk_get_request(q, rw, GFP_KERNEL);
-       if (!rq)
-               return ERR_PTR(-ENOMEM);
+       if (IS_ERR(rq))
+               return rq;
        ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm);
        if (ret)
                goto out;
@@ -284,8 +284,8 @@ bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,
                }
 
                next_rq = blk_get_request(q, READ, GFP_KERNEL);
-               if (!next_rq) {
-                       ret = -ENOMEM;
+               if (IS_ERR(next_rq)) {
+                       ret = PTR_ERR(next_rq);
                        goto out;
                }
                rq->next_rq = next_rq;
index 1b4988b..1d9a73d 100644 (file)
@@ -312,8 +312,8 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
                }
 
        rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
-       if (!rq)
-               return -ENOMEM;
+       if (IS_ERR(rq))
+               return PTR_ERR(rq);
 
        if (blk_fill_sghdr_rq(q, rq, hdr, mode)) {
                blk_put_request(rq);
@@ -459,6 +459,10 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
        }
 
        rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT);
+       if (IS_ERR(rq)) {
+               err = PTR_ERR(rq);
+               goto error_free_buffer;
+       }
 
        cmdlen = COMMAND_SIZE(opcode);
 
@@ -530,8 +534,9 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
        }
        
 error:
-       kfree(buffer);
        blk_put_request(rq);
+error_free_buffer:
+       kfree(buffer);
        return err;
 }
 EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
@@ -544,6 +549,8 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
        int err;
 
        rq = blk_get_request(q, WRITE, __GFP_WAIT);
+       if (IS_ERR(rq))
+               return PTR_ERR(rq);
        rq->cmd_type = REQ_TYPE_BLOCK_PC;
        rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
        rq->cmd[0] = cmd;
index 19ad8f0..2af4101 100644 (file)
@@ -722,6 +722,8 @@ static int pd_special_command(struct pd_unit *disk,
        int err = 0;
 
        rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
+       if (IS_ERR(rq))
+               return PTR_ERR(rq);
 
        rq->cmd_type = REQ_TYPE_SPECIAL;
        rq->special = func;
index f5d0ea1..73b2566 100644 (file)
@@ -712,6 +712,8 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
 
        rq = blk_get_request(q, (cgc->data_direction == CGC_DATA_WRITE) ?
                             WRITE : READ, __GFP_WAIT);
+       if (IS_ERR(rq))
+               return PTR_ERR(rq);
 
        if (cgc->buflen) {
                if (blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen, __GFP_WAIT))
index 3fb6ab4..911b7fc 100644 (file)
@@ -568,7 +568,7 @@ static struct carm_request *carm_get_special(struct carm_host *host)
                return NULL;
 
        rq = blk_get_request(host->oob_q, WRITE /* bogus */, GFP_KERNEL);
-       if (!rq) {
+       if (IS_ERR(rq)) {
                spin_lock_irqsave(&host->lock, flags);
                carm_put_request(host, crq);
                spin_unlock_irqrestore(&host->lock, flags);
index 8a3aff7..85e63d3 100644 (file)
@@ -2161,8 +2161,8 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
                len = nr * CD_FRAMESIZE_RAW;
 
                rq = blk_get_request(q, READ, GFP_KERNEL);
-               if (!rq) {
-                       ret = -ENOMEM;
+               if (IS_ERR(rq)) {
+                       ret = PTR_ERR(rq);
                        break;
                }
 
index 6ab9ab2..5d074e2 100644 (file)
@@ -46,7 +46,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
         * timeout has expired, so power management will be reenabled.
         */
        rq = blk_get_request(q, READ, GFP_NOWAIT);
-       if (unlikely(!rq))
+       if (IS_ERR(rq))
                goto out;
 
        rq->cmd[0] = REQ_UNPARK_HEADS;
index 68adb89..125650c 100644 (file)
@@ -115,7 +115,7 @@ static struct request *get_alua_req(struct scsi_device *sdev,
 
        rq = blk_get_request(q, rw, GFP_NOIO);
 
-       if (!rq) {
+       if (IS_ERR(rq)) {
                sdev_printk(KERN_INFO, sdev,
                            "%s: blk_get_request failed\n", __func__);
                return NULL;
index e1c8be0..2ec3261 100644 (file)
@@ -275,7 +275,7 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
 
        rq = blk_get_request(sdev->request_queue,
                        (cmd != INQUIRY) ? WRITE : READ, GFP_NOIO);
-       if (!rq) {
+       if (IS_ERR(rq)) {
                sdev_printk(KERN_INFO, sdev, "get_req: blk_get_request failed");
                return NULL;
        }
index 084062b..1cf4019 100644 (file)
@@ -117,7 +117,7 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
 
 retry:
        req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
-       if (!req)
+       if (IS_ERR(req))
                return SCSI_DH_RES_TEMP_UNAVAIL;
 
        req->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -247,7 +247,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
        struct request *req;
 
        req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
-       if (!req)
+       if (IS_ERR(req))
                return SCSI_DH_RES_TEMP_UNAVAIL;
 
        req->cmd_type = REQ_TYPE_BLOCK_PC;
index 69c915a..009bd8f 100644 (file)
@@ -274,7 +274,7 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
 
        rq = blk_get_request(q, rw, GFP_NOIO);
 
-       if (!rq) {
+       if (IS_ERR(rq)) {
                sdev_printk(KERN_INFO, sdev,
                                "get_rdac_req: blk_get_request failed.\n");
                return NULL;
index aa66361..9107826 100644 (file)
@@ -1567,8 +1567,8 @@ static struct request *_make_request(struct request_queue *q, bool has_write,
                struct request *req;
 
                req = blk_get_request(q, has_write ? WRITE : READ, flags);
-               if (unlikely(!req))
-                       return ERR_PTR(-ENOMEM);
+               if (IS_ERR(req))
+                       return req;
 
                return req;
        }
index 21883a2..826cda9 100644 (file)
@@ -362,7 +362,7 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
        int write = (data_direction == DMA_TO_DEVICE);
 
        req = blk_get_request(SRpnt->stp->device->request_queue, write, GFP_KERNEL);
-       if (!req)
+       if (IS_ERR(req))
                return DRIVER_ERROR << 24;
 
        req->cmd_type = REQ_TYPE_BLOCK_PC;
index 3668b1b..5d73219 100644 (file)
@@ -1652,6 +1652,8 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
         * request becomes available
         */
        req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL);
+       if (IS_ERR(req))
+               return;
 
        req->cmd[0] = ALLOW_MEDIUM_REMOVAL;
        req->cmd[1] = 0;
index df5e961..2e54684 100644 (file)
@@ -1650,8 +1650,8 @@ static int sg_start_req(Sg_request *srp, unsigned char *cmd)
                                   dxfer_len));
 
        rq = blk_get_request(q, rw, GFP_ATOMIC);
-       if (!rq)
-               return -ENOMEM;
+       if (IS_ERR(rq))
+               return PTR_ERR(rq);
 
        memcpy(rq->cmd, cmd, hp->cmd_len);
 
index 2a32036..f0caf84 100644 (file)
@@ -481,7 +481,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 
        req = blk_get_request(SRpnt->stp->device->request_queue, write,
                              GFP_KERNEL);
-       if (!req)
+       if (IS_ERR(req))
                return DRIVER_ERROR << 24;
 
        req->cmd_type = REQ_TYPE_BLOCK_PC;
index 3250ba2..29260c4 100644 (file)
@@ -1050,7 +1050,7 @@ pscsi_execute_cmd(struct se_cmd *cmd)
                req = blk_get_request(pdv->pdv_sd->request_queue,
                                (data_direction == DMA_TO_DEVICE),
                                GFP_KERNEL);
-               if (!req || IS_ERR(req)) {
+               if (IS_ERR(req)) {
                        pr_err("PSCSI: blk_get_request() failed: %ld\n",
                                        req ? IS_ERR(req) : -ENOMEM);
                        ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;