block: sanitize blk_get_request calling conventions

Switch everyone to blk_get_request_flags, and then rename
blk_get_request_flags to blk_get_request.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

24 files changed, 32 insertions, 35 deletions

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 27a44b97393a..8961b190e256 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -740,7 +740,7 @@ static int pd_special_command(struct pd_unit *disk,
 {
         struct request *rq;
 
-        rq = blk_get_request(disk->gd->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(disk->gd->queue, REQ_OP_DRV_IN, 0);
         if (IS_ERR(rq))
                 return PTR_ERR(rq);
 
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index c61d20c9f3f8..4880a4a9f52d 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -704,7 +704,7 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
         int ret = 0;
 
         rq = blk_get_request(q, (cgc->data_direction == CGC_DATA_WRITE) ?
-                             REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, __GFP_RECLAIM);
+                             REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
         if (IS_ERR(rq))
                 return PTR_ERR(rq);
 
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 08586dc14e85..4d90e5eba2f5 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -567,7 +567,7 @@ static struct carm_request *carm_get_special(struct carm_host *host)
         if (!crq)
                 return NULL;
 
-        rq = blk_get_request(host->oob_q, REQ_OP_DRV_OUT, GFP_KERNEL);
+        rq = blk_get_request(host->oob_q, REQ_OP_DRV_OUT, 0);
         if (IS_ERR(rq)) {
                 spin_lock_irqsave(&host->lock, flags);
                 carm_put_request(host, crq);
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 4a07593c2efd..0617b9922d59 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -298,7 +298,7 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
         struct request *req;
         int err;
 
-        req = blk_get_request(q, REQ_OP_DRV_IN, GFP_KERNEL);
+        req = blk_get_request(q, REQ_OP_DRV_IN, 0);
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index bfc566d3f31a..9adc8c3eb0fa 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -2192,7 +2192,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
 
                 len = nr * CD_FRAMESIZE_RAW;
 
-                rq = blk_get_request(q, REQ_OP_SCSI_IN, GFP_KERNEL);
+                rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
                 if (IS_ERR(rq)) {
                         ret = PTR_ERR(rq);
                         break;
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 0e6bc631a1ca..8b2b72b93885 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -92,7 +92,7 @@ int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
         struct request *rq;
         int error;
 
-        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_MISC;
         rq->special = (char *)pc;
 
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 5a8e8e3c22cd..32af6f063cb3 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -437,7 +437,7 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
                 bool delay = false;
 
                 rq = blk_get_request(drive->queue,
-                        write ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN,  __GFP_RECLAIM);
+                        write ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
                 memcpy(scsi_req(rq)->cmd, cmd, BLK_MAX_CDB);
                 ide_req(rq)->type = ATA_PRIV_PC;
                 rq->rq_flags |= rq_flags;
diff --git a/drivers/ide/ide-cd_ioctl.c b/drivers/ide/ide-cd_ioctl.c
index 2acca12b9c94..b1322400887b 100644
--- a/drivers/ide/ide-cd_ioctl.c
+++ b/drivers/ide/ide-cd_ioctl.c
@@ -304,7 +304,7 @@ int ide_cdrom_reset(struct cdrom_device_info *cdi)
         struct request *rq;
         int ret;
 
-        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_MISC;
         rq->rq_flags = RQF_QUIET;
         blk_execute_rq(drive->queue, cd->disk, rq, 0);
diff --git a/drivers/ide/ide-devsets.c b/drivers/ide/ide-devsets.c
index 4e20747af32e..f4f8afdf8bbe 100644
--- a/drivers/ide/ide-devsets.c
+++ b/drivers/ide/ide-devsets.c
@@ -166,7 +166,7 @@ int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
         if (!(setting->flags & DS_SYNC))
                 return setting->set(drive, arg);
 
-        rq = blk_get_request(q, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(q, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_MISC;
         scsi_req(rq)->cmd_len = 5;
         scsi_req(rq)->cmd[0] = REQ_DEVSET_EXEC;
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index f1a7c58fe418..e3b4e659082d 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -478,7 +478,7 @@ static int set_multcount(ide_drive_t *drive, int arg)
         if (drive->special_flags & IDE_SFLAG_SET_MULTMODE)
                 return -EBUSY;
 
-        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_TASKFILE;
 
         drive->mult_req = arg;
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index 3661abb16a5f..af5119a73689 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -125,7 +125,7 @@ static int ide_cmd_ioctl(ide_drive_t *drive, unsigned long arg)
         if (NULL == (void *) arg) {
                 struct request *rq;
 
-                rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+                rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
                 ide_req(rq)->type = ATA_PRIV_TASKFILE;
                 blk_execute_rq(drive->queue, NULL, rq, 0);
                 err = scsi_req(rq)->result ? -EIO : 0;
@@ -222,7 +222,7 @@ static int generic_drive_reset(ide_drive_t *drive)
         struct request *rq;
         int ret = 0;
 
-        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_MISC;
         scsi_req(rq)->cmd_len = 1;
         scsi_req(rq)->cmd[0] = REQ_DRIVE_RESET;
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index 6465bcc7cea6..622f0edb3945 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -32,7 +32,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
         }
         spin_unlock_irq(&hwif->lock);
 
-        rq = blk_get_request(q, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(q, REQ_OP_DRV_IN, 0);
         scsi_req(rq)->cmd[0] = REQ_PARK_HEADS;
         scsi_req(rq)->cmd_len = 1;
         ide_req(rq)->type = ATA_PRIV_MISC;
@@ -47,7 +47,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
          * Make sure that *some* command is sent to the drive after the
          * timeout has expired, so power management will be reenabled.
          */
-        rq = blk_get_request(q, REQ_OP_DRV_IN, GFP_NOWAIT);
+        rq = blk_get_request(q, REQ_OP_DRV_IN, BLK_MQ_REQ_NOWAIT);
         if (IS_ERR(rq))
                 goto out;
 
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index ad8a125defdd..59217aa1d1fb 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -19,7 +19,7 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         }
 
         memset(&rqpm, 0, sizeof(rqpm));
-        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_PM_SUSPEND;
         rq->special = &rqpm;
         rqpm.pm_step = IDE_PM_START_SUSPEND;
@@ -90,8 +90,7 @@ int generic_ide_resume(struct device *dev)
         }
 
         memset(&rqpm, 0, sizeof(rqpm));
-        rq = blk_get_request_flags(drive->queue, REQ_OP_DRV_IN,
-                                   BLK_MQ_REQ_PREEMPT);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, BLK_MQ_REQ_PREEMPT);
         ide_req(rq)->type = ATA_PRIV_PM_RESUME;
         rq->special = &rqpm;
         rqpm.pm_step = IDE_PM_START_RESUME;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index fd57e8ccc47a..66661031f3f1 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -854,7 +854,7 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
         BUG_ON(cmd != REQ_IDETAPE_READ && cmd != REQ_IDETAPE_WRITE);
         BUG_ON(size < 0 || size % tape->blk_size);
 
-        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_MISC;
         scsi_req(rq)->cmd[13] = cmd;
         rq->rq_disk = tape->disk;
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index abe0822dd429..6308bb0dab50 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -431,7 +431,7 @@ int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
 
         rq = blk_get_request(drive->queue,
                 (cmd->tf_flags & IDE_TFLAG_WRITE) ?
-                        REQ_OP_DRV_OUT : REQ_OP_DRV_IN, __GFP_RECLAIM);
+                        REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
         ide_req(rq)->type = ATA_PRIV_TASKFILE;
 
         /*
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 203a0419d2b0..d94ba6f72ff5 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -520,7 +520,8 @@ static int multipath_clone_and_map(struct dm_target *ti, struct request *rq,
 
         bdev = pgpath->path.dev->bdev;
         q = bdev_get_queue(bdev);
-        clone = blk_get_request(q, rq->cmd_flags | REQ_NOMERGE, GFP_ATOMIC);
+        clone = blk_get_request(q, rq->cmd_flags | REQ_NOMERGE,
+                        BLK_MQ_REQ_NOWAIT);
         if (IS_ERR(clone)) {
                 /* EBUSY, ENODEV or EWOULDBLOCK: requeue */
                 if (blk_queue_dying(q)) {
diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c
index 9e923cd1d80e..6e3bde824db8 100644
--- a/drivers/mmc/core/block.c
+++ b/drivers/mmc/core/block.c
@@ -244,7 +244,7 @@ static ssize_t power_ro_lock_store(struct device *dev,
         mq = &md->queue;
 
         /* Dispatch locking to the block layer */
-        req = blk_get_request(mq->queue, REQ_OP_DRV_OUT, __GFP_RECLAIM);
+        req = blk_get_request(mq->queue, REQ_OP_DRV_OUT, 0);
         if (IS_ERR(req)) {
                 count = PTR_ERR(req);
                 goto out_put;
@@ -650,8 +650,7 @@ static int mmc_blk_ioctl_cmd(struct mmc_blk_data *md,
          */
         mq = &md->queue;
         req = blk_get_request(mq->queue,
-                idata->ic.write_flag ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN,
-                __GFP_RECLAIM);
+                idata->ic.write_flag ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
         if (IS_ERR(req)) {
                 err = PTR_ERR(req);
                 goto cmd_done;
@@ -721,8 +720,7 @@ static int mmc_blk_ioctl_multi_cmd(struct mmc_blk_data *md,
          */
         mq = &md->queue;
         req = blk_get_request(mq->queue,
-                idata[0]->ic.write_flag ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN,
-                __GFP_RECLAIM);
+                idata[0]->ic.write_flag ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
         if (IS_ERR(req)) {
                 err = PTR_ERR(req);
                 goto cmd_err;
@@ -2750,7 +2748,7 @@ static int mmc_dbg_card_status_get(void *data, u64 *val)
         int ret;
 
         /* Ask the block layer about the card status */
-        req = blk_get_request(mq->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        req = blk_get_request(mq->queue, REQ_OP_DRV_IN, 0);
         if (IS_ERR(req))
                 return PTR_ERR(req);
         req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_GET_CARD_STATUS;
@@ -2786,7 +2784,7 @@ static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
                 return -ENOMEM;
 
         /* Ask the block layer for the EXT CSD */
-        req = blk_get_request(mq->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
+        req = blk_get_request(mq->queue, REQ_OP_DRV_IN, 0);
         if (IS_ERR(req)) {
                 err = PTR_ERR(req);
                 goto out_free;
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index f48bae267dc2..5a33e1ad9881 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -1570,7 +1570,7 @@ static struct request *_make_request(struct request_queue *q, bool has_write,
         int ret;
 
         req = blk_get_request(q, has_write ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN,
-                        GFP_KERNEL);
+                        0);
         if (IS_ERR(req))
                 return req;
 
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 20ec1c01dbd5..2bbe797f8c3d 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -368,7 +368,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 ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, GFP_KERNEL);
+                        write ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
         if (IS_ERR(req))
                 return DRIVER_ERROR << 24;
 
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 946039117bf4..61d280f560df 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1937,7 +1937,7 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
          * blk_get_request with GFP_KERNEL (__GFP_RECLAIM) sleeps until a
          * request becomes available
          */
-        req = blk_get_request(sdev->request_queue, REQ_OP_SCSI_IN, GFP_KERNEL);
+        req = blk_get_request(sdev->request_queue, REQ_OP_SCSI_IN, 0);
         if (IS_ERR(req))
                 return;
         rq = scsi_req(req);
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index e9b4f279d29c..6b0f3ec487bd 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -265,7 +265,7 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
         struct scsi_request *rq;
         int ret = DRIVER_ERROR << 24;
 
-        req = blk_get_request_flags(sdev->request_queue,
+        req = blk_get_request(sdev->request_queue,
                         data_direction == DMA_TO_DEVICE ?
                         REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, BLK_MQ_REQ_PREEMPT);
         if (IS_ERR(req))
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index c198b96368dd..0512648ebc8e 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1715,7 +1715,7 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
          * does not sleep except under memory pressure.
          */
         rq = blk_get_request(q, hp->dxfer_direction == SG_DXFER_TO_DEV ?
-                        REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, GFP_KERNEL);
+                        REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
         if (IS_ERR(rq)) {
                 kfree(long_cmdp);
                 return PTR_ERR(rq);
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 6c399480783d..a427ce9497be 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -545,7 +545,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 
         req = blk_get_request(SRpnt->stp->device->request_queue,
                         data_direction == DMA_TO_DEVICE ?
-                        REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, GFP_KERNEL);
+                        REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
         if (IS_ERR(req))
                 return DRIVER_ERROR << 24;
         rq = scsi_req(req);
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 6cb933ecc084..668934ea74cb 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -986,8 +986,7 @@ pscsi_execute_cmd(struct se_cmd *cmd)
 
         req = blk_get_request(pdv->pdv_sd->request_queue,
                         cmd->data_direction == DMA_TO_DEVICE ?
-                        REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN,
-                        GFP_KERNEL);
+                        REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
         if (IS_ERR(req)) {
                 pr_err("PSCSI: blk_get_request() failed\n");
                 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;