blk-mq: remove the error argument to blk_mq_complete_request

[karo-tx-linux.git] / drivers / block / loop.c

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 4b52a16903298c5fe22cd6529578dfdf47fd27b9..994403efee19de163238b62e722fb6a478b5f7d5 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -445,32 +445,27 @@ static int lo_req_flush(struct loop_device *lo, struct request *rq)
        return ret;
 }
 
-static inline void handle_partial_read(struct loop_cmd *cmd, long bytes)
+static void lo_complete_rq(struct request *rq)
 {
-       if (bytes < 0 || op_is_write(req_op(cmd->rq)))
-               return;
+       struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
 
-       if (unlikely(bytes < blk_rq_bytes(cmd->rq))) {
+       if (unlikely(req_op(cmd->rq) == REQ_OP_READ && cmd->use_aio &&
+                    cmd->ret >= 0 && cmd->ret < blk_rq_bytes(cmd->rq))) {
                struct bio *bio = cmd->rq->bio;
 
-               bio_advance(bio, bytes);
+               bio_advance(bio, cmd->ret);
                zero_fill_bio(bio);
        }
+
+       blk_mq_end_request(rq, cmd->ret < 0 ? -EIO : 0);
 }
 
 static void lo_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
 {
        struct loop_cmd *cmd = container_of(iocb, struct loop_cmd, iocb);
-       struct request *rq = cmd->rq;
-
-       handle_partial_read(cmd, ret);
-
-       if (ret > 0)
-               ret = 0;
-       else if (ret < 0)
-               ret = -EIO;
 
-       blk_mq_complete_request(rq, ret);
+       cmd->ret = ret;
+       blk_mq_complete_request(cmd->rq);
 }
 
 static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
@@ -501,9 +496,9 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
        cmd->iocb.ki_flags = IOCB_DIRECT;
 
        if (rw == WRITE)
-               ret = file->f_op->write_iter(&cmd->iocb, &iter);
+               ret = call_write_iter(file, &cmd->iocb, &iter);
        else
-               ret = file->f_op->read_iter(&cmd->iocb, &iter);
+               ret = call_read_iter(file, &cmd->iocb, &iter);
 
        if (ret != -EIOCBQUEUED)
                cmd->iocb.ki_complete(&cmd->iocb, ret, 0);
@@ -528,6 +523,7 @@ static int do_req_filebacked(struct loop_device *lo, struct request *rq)
        case REQ_OP_FLUSH:
                return lo_req_flush(lo, rq);
        case REQ_OP_DISCARD:
+       case REQ_OP_WRITE_ZEROES:
                return lo_discard(lo, rq, pos);
        case REQ_OP_WRITE:
                if (lo->transfer)
@@ -826,7 +822,7 @@ static void loop_config_discard(struct loop_device *lo)
                q->limits.discard_granularity = 0;
                q->limits.discard_alignment = 0;
                blk_queue_max_discard_sectors(q, 0);
-               q->limits.discard_zeroes_data = 0;
+               blk_queue_max_write_zeroes_sectors(q, 0);
                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
                return;
        }
@@ -834,7 +830,7 @@ static void loop_config_discard(struct loop_device *lo)
        q->limits.discard_granularity = inode->i_sb->s_blocksize;
        q->limits.discard_alignment = 0;
        blk_queue_max_discard_sectors(q, UINT_MAX >> 9);
-       q->limits.discard_zeroes_data = 1;
+       blk_queue_max_write_zeroes_sectors(q, UINT_MAX >> 9);
        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 }
 
@@ -1142,13 +1138,6 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
             (info->lo_flags & LO_FLAGS_AUTOCLEAR))
                lo->lo_flags ^= LO_FLAGS_AUTOCLEAR;
 
-       if ((info->lo_flags & LO_FLAGS_PARTSCAN) &&
-            !(lo->lo_flags & LO_FLAGS_PARTSCAN)) {
-               lo->lo_flags |= LO_FLAGS_PARTSCAN;
-               lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
-               loop_reread_partitions(lo, lo->lo_device);
-       }
-
        lo->lo_encrypt_key_size = info->lo_encrypt_key_size;
        lo->lo_init[0] = info->lo_init[0];
        lo->lo_init[1] = info->lo_init[1];
@@ -1163,6 +1152,14 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
 
  exit:
        blk_mq_unfreeze_queue(lo->lo_queue);
+
+       if (!err && (info->lo_flags & LO_FLAGS_PARTSCAN) &&
+            !(lo->lo_flags & LO_FLAGS_PARTSCAN)) {
+               lo->lo_flags |= LO_FLAGS_PARTSCAN;
+               lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
+               loop_reread_partitions(lo, lo->lo_device);
+       }
+
        return err;
 }
 
@@ -1175,7 +1172,8 @@ loop_get_status(struct loop_device *lo, struct loop_info64 *info)
 
        if (lo->lo_state != Lo_bound)
                return -ENXIO;
-       error = vfs_getattr(&file->f_path, &stat);
+       error = vfs_getattr(&file->f_path, &stat,
+                           STATX_INO, AT_STATX_SYNC_AS_STAT);
        if (error)
                return error;
        memset(info, 0, sizeof(*info));
@@ -1658,6 +1656,7 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx,
        switch (req_op(cmd->rq)) {
        case REQ_OP_FLUSH:
        case REQ_OP_DISCARD:
+       case REQ_OP_WRITE_ZEROES:
                cmd->use_aio = false;
                break;
        default:
@@ -1684,8 +1683,10 @@ static void loop_handle_cmd(struct loop_cmd *cmd)
        ret = do_req_filebacked(lo, cmd->rq);
  failed:
        /* complete non-aio request */
-       if (!cmd->use_aio || ret)
-               blk_mq_complete_request(cmd->rq, ret ? -EIO : 0);
+       if (!cmd->use_aio || ret) {
+               cmd->ret = ret ? -EIO : 0;
+               blk_mq_complete_request(cmd->rq);
+       }
 }
 
 static void loop_queue_work(struct kthread_work *work)
@@ -1708,9 +1709,10 @@ static int loop_init_request(void *data, struct request *rq,
        return 0;
 }
 
-static struct blk_mq_ops loop_mq_ops = {
+static const struct blk_mq_ops loop_mq_ops = {
        .queue_rq       = loop_queue_rq,
        .init_request   = loop_init_request,
+       .complete       = lo_complete_rq,
 };
 
 static int loop_add(struct loop_device **l, int i)