mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-18 00:24:58 +08:00
0048b4837a
Inside timeout handler, blk_mq_tag_to_rq() is called to retrieve the request from one tag. This way is obviously wrong because the request can be freed any time and some fiedds of the request can't be trusted, then kernel oops might be triggered[1]. Currently wrt. blk_mq_tag_to_rq(), the only special case is that the flush request can share same tag with the request cloned from, and the two requests can't be active at the same time, so this patch fixes the above issue by updating tags->rqs[tag] with the active request(either flush rq or the request cloned from) of the tag. Also blk_mq_tag_to_rq() gets much simplified with this patch. Given blk_mq_tag_to_rq() is mainly for drivers and the caller must make sure the request can't be freed, so in bt_for_each() this helper is replaced with tags->rqs[tag]. [1] kernel oops log [ 439.696220] BUG: unable to handle kernel NULL pointer dereference at 0000000000000158^M [ 439.697162] IP: [<ffffffff812d89ba>] blk_mq_tag_to_rq+0x21/0x6e^M [ 439.700653] PGD 7ef765067 PUD 7ef764067 PMD 0 ^M [ 439.700653] Oops: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC ^M [ 439.700653] Dumping ftrace buffer:^M [ 439.700653] (ftrace buffer empty)^M [ 439.700653] Modules linked in: nbd ipv6 kvm_intel kvm serio_raw^M [ 439.700653] CPU: 6 PID: 2779 Comm: stress-ng-sigfd Not tainted 4.2.0-rc5-next-20150805+ #265^M [ 439.730500] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Bochs 01/01/2011^M [ 439.730500] task: ffff880605308000 ti: ffff88060530c000 task.ti: ffff88060530c000^M [ 439.730500] RIP: 0010:[<ffffffff812d89ba>] [<ffffffff812d89ba>] blk_mq_tag_to_rq+0x21/0x6e^M [ 439.730500] RSP: 0018:ffff880819203da0 EFLAGS: 00010283^M [ 439.730500] RAX: ffff880811b0e000 RBX: ffff8800bb465f00 RCX: 0000000000000002^M [ 439.730500] RDX: 0000000000000000 RSI: 0000000000000202 RDI: 0000000000000000^M [ 439.730500] RBP: ffff880819203db0 R08: 0000000000000002 R09: 0000000000000000^M [ 439.730500] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000202^M [ 439.730500] R13: ffff880814104800 R14: 0000000000000002 R15: ffff880811a2ea00^M [ 439.730500] FS: 00007f165b3f5740(0000) GS:ffff880819200000(0000) knlGS:0000000000000000^M [ 439.730500] CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b^M [ 439.730500] CR2: 0000000000000158 CR3: 00000007ef766000 CR4: 00000000000006e0^M [ 439.730500] Stack:^M [ 439.730500] 0000000000000008 ffff8808114eed90 ffff880819203e00 ffffffff812dc104^M [ 439.755663] ffff880819203e40 ffffffff812d9f5e 0000020000000000 ffff8808114eed80^M [ 439.755663] Call Trace:^M [ 439.755663] <IRQ> ^M [ 439.755663] [<ffffffff812dc104>] bt_for_each+0x6e/0xc8^M [ 439.755663] [<ffffffff812d9f5e>] ? blk_mq_rq_timed_out+0x6a/0x6a^M [ 439.755663] [<ffffffff812d9f5e>] ? blk_mq_rq_timed_out+0x6a/0x6a^M [ 439.755663] [<ffffffff812dc1b3>] blk_mq_tag_busy_iter+0x55/0x5e^M [ 439.755663] [<ffffffff812d88b4>] ? blk_mq_bio_to_request+0x38/0x38^M [ 439.755663] [<ffffffff812d8911>] blk_mq_rq_timer+0x5d/0xd4^M [ 439.755663] [<ffffffff810a3e10>] call_timer_fn+0xf7/0x284^M [ 439.755663] [<ffffffff810a3d1e>] ? call_timer_fn+0x5/0x284^M [ 439.755663] [<ffffffff812d88b4>] ? blk_mq_bio_to_request+0x38/0x38^M [ 439.755663] [<ffffffff810a46d6>] run_timer_softirq+0x1ce/0x1f8^M [ 439.755663] [<ffffffff8104c367>] __do_softirq+0x181/0x3a4^M [ 439.755663] [<ffffffff8104c76e>] irq_exit+0x40/0x94^M [ 439.755663] [<ffffffff81031482>] smp_apic_timer_interrupt+0x33/0x3e^M [ 439.755663] [<ffffffff815559a4>] apic_timer_interrupt+0x84/0x90^M [ 439.755663] <EOI> ^M [ 439.755663] [<ffffffff81554350>] ? _raw_spin_unlock_irq+0x32/0x4a^M [ 439.755663] [<ffffffff8106a98b>] finish_task_switch+0xe0/0x163^M [ 439.755663] [<ffffffff8106a94d>] ? finish_task_switch+0xa2/0x163^M [ 439.755663] [<ffffffff81550066>] __schedule+0x469/0x6cd^M [ 439.755663] [<ffffffff8155039b>] schedule+0x82/0x9a^M [ 439.789267] [<ffffffff8119b28b>] signalfd_read+0x186/0x49a^M [ 439.790911] [<ffffffff8106d86a>] ? wake_up_q+0x47/0x47^M [ 439.790911] [<ffffffff811618c2>] __vfs_read+0x28/0x9f^M [ 439.790911] [<ffffffff8117a289>] ? __fget_light+0x4d/0x74^M [ 439.790911] [<ffffffff811620a7>] vfs_read+0x7a/0xc6^M [ 439.790911] [<ffffffff8116292b>] SyS_read+0x49/0x7f^M [ 439.790911] [<ffffffff81554c17>] entry_SYSCALL_64_fastpath+0x12/0x6f^M [ 439.790911] Code: 48 89 e5 e8 a9 b8 e7 ff 5d c3 0f 1f 44 00 00 55 89 f2 48 89 e5 41 54 41 89 f4 53 48 8b 47 60 48 8b 1c d0 48 8b 7b 30 48 8b 53 38 <48> 8b 87 58 01 00 00 48 85 c0 75 09 48 8b 97 88 0c 00 00 eb 10 ^M [ 439.790911] RIP [<ffffffff812d89ba>] blk_mq_tag_to_rq+0x21/0x6e^M [ 439.790911] RSP <ffff880819203da0>^M [ 439.790911] CR2: 0000000000000158^M [ 439.790911] ---[ end trace d40af58949325661 ]---^M Cc: <stable@vger.kernel.org> Signed-off-by: Ming Lei <ming.lei@canonical.com> Signed-off-by: Jens Axboe <axboe@fb.com>
543 lines
15 KiB
C
543 lines
15 KiB
C
/*
|
|
* Functions to sequence FLUSH and FUA writes.
|
|
*
|
|
* Copyright (C) 2011 Max Planck Institute for Gravitational Physics
|
|
* Copyright (C) 2011 Tejun Heo <tj@kernel.org>
|
|
*
|
|
* This file is released under the GPLv2.
|
|
*
|
|
* REQ_{FLUSH|FUA} requests are decomposed to sequences consisted of three
|
|
* optional steps - PREFLUSH, DATA and POSTFLUSH - according to the request
|
|
* properties and hardware capability.
|
|
*
|
|
* If a request doesn't have data, only REQ_FLUSH makes sense, which
|
|
* indicates a simple flush request. If there is data, REQ_FLUSH indicates
|
|
* that the device cache should be flushed before the data is executed, and
|
|
* REQ_FUA means that the data must be on non-volatile media on request
|
|
* completion.
|
|
*
|
|
* If the device doesn't have writeback cache, FLUSH and FUA don't make any
|
|
* difference. The requests are either completed immediately if there's no
|
|
* data or executed as normal requests otherwise.
|
|
*
|
|
* If the device has writeback cache and supports FUA, REQ_FLUSH is
|
|
* translated to PREFLUSH but REQ_FUA is passed down directly with DATA.
|
|
*
|
|
* If the device has writeback cache and doesn't support FUA, REQ_FLUSH is
|
|
* translated to PREFLUSH and REQ_FUA to POSTFLUSH.
|
|
*
|
|
* The actual execution of flush is double buffered. Whenever a request
|
|
* needs to execute PRE or POSTFLUSH, it queues at
|
|
* fq->flush_queue[fq->flush_pending_idx]. Once certain criteria are met, a
|
|
* flush is issued and the pending_idx is toggled. When the flush
|
|
* completes, all the requests which were pending are proceeded to the next
|
|
* step. This allows arbitrary merging of different types of FLUSH/FUA
|
|
* requests.
|
|
*
|
|
* Currently, the following conditions are used to determine when to issue
|
|
* flush.
|
|
*
|
|
* C1. At any given time, only one flush shall be in progress. This makes
|
|
* double buffering sufficient.
|
|
*
|
|
* C2. Flush is deferred if any request is executing DATA of its sequence.
|
|
* This avoids issuing separate POSTFLUSHes for requests which shared
|
|
* PREFLUSH.
|
|
*
|
|
* C3. The second condition is ignored if there is a request which has
|
|
* waited longer than FLUSH_PENDING_TIMEOUT. This is to avoid
|
|
* starvation in the unlikely case where there are continuous stream of
|
|
* FUA (without FLUSH) requests.
|
|
*
|
|
* For devices which support FUA, it isn't clear whether C2 (and thus C3)
|
|
* is beneficial.
|
|
*
|
|
* Note that a sequenced FLUSH/FUA request with DATA is completed twice.
|
|
* Once while executing DATA and again after the whole sequence is
|
|
* complete. The first completion updates the contained bio but doesn't
|
|
* finish it so that the bio submitter is notified only after the whole
|
|
* sequence is complete. This is implemented by testing REQ_FLUSH_SEQ in
|
|
* req_bio_endio().
|
|
*
|
|
* The above peculiarity requires that each FLUSH/FUA request has only one
|
|
* bio attached to it, which is guaranteed as they aren't allowed to be
|
|
* merged in the usual way.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/bio.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/blk-mq.h>
|
|
|
|
#include "blk.h"
|
|
#include "blk-mq.h"
|
|
#include "blk-mq-tag.h"
|
|
|
|
/* FLUSH/FUA sequences */
|
|
enum {
|
|
REQ_FSEQ_PREFLUSH = (1 << 0), /* pre-flushing in progress */
|
|
REQ_FSEQ_DATA = (1 << 1), /* data write in progress */
|
|
REQ_FSEQ_POSTFLUSH = (1 << 2), /* post-flushing in progress */
|
|
REQ_FSEQ_DONE = (1 << 3),
|
|
|
|
REQ_FSEQ_ACTIONS = REQ_FSEQ_PREFLUSH | REQ_FSEQ_DATA |
|
|
REQ_FSEQ_POSTFLUSH,
|
|
|
|
/*
|
|
* If flush has been pending longer than the following timeout,
|
|
* it's issued even if flush_data requests are still in flight.
|
|
*/
|
|
FLUSH_PENDING_TIMEOUT = 5 * HZ,
|
|
};
|
|
|
|
static bool blk_kick_flush(struct request_queue *q,
|
|
struct blk_flush_queue *fq);
|
|
|
|
static unsigned int blk_flush_policy(unsigned int fflags, struct request *rq)
|
|
{
|
|
unsigned int policy = 0;
|
|
|
|
if (blk_rq_sectors(rq))
|
|
policy |= REQ_FSEQ_DATA;
|
|
|
|
if (fflags & REQ_FLUSH) {
|
|
if (rq->cmd_flags & REQ_FLUSH)
|
|
policy |= REQ_FSEQ_PREFLUSH;
|
|
if (!(fflags & REQ_FUA) && (rq->cmd_flags & REQ_FUA))
|
|
policy |= REQ_FSEQ_POSTFLUSH;
|
|
}
|
|
return policy;
|
|
}
|
|
|
|
static unsigned int blk_flush_cur_seq(struct request *rq)
|
|
{
|
|
return 1 << ffz(rq->flush.seq);
|
|
}
|
|
|
|
static void blk_flush_restore_request(struct request *rq)
|
|
{
|
|
/*
|
|
* After flush data completion, @rq->bio is %NULL but we need to
|
|
* complete the bio again. @rq->biotail is guaranteed to equal the
|
|
* original @rq->bio. Restore it.
|
|
*/
|
|
rq->bio = rq->biotail;
|
|
|
|
/* make @rq a normal request */
|
|
rq->cmd_flags &= ~REQ_FLUSH_SEQ;
|
|
rq->end_io = rq->flush.saved_end_io;
|
|
}
|
|
|
|
static bool blk_flush_queue_rq(struct request *rq, bool add_front)
|
|
{
|
|
if (rq->q->mq_ops) {
|
|
struct request_queue *q = rq->q;
|
|
|
|
blk_mq_add_to_requeue_list(rq, add_front);
|
|
blk_mq_kick_requeue_list(q);
|
|
return false;
|
|
} else {
|
|
if (add_front)
|
|
list_add(&rq->queuelist, &rq->q->queue_head);
|
|
else
|
|
list_add_tail(&rq->queuelist, &rq->q->queue_head);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* blk_flush_complete_seq - complete flush sequence
|
|
* @rq: FLUSH/FUA request being sequenced
|
|
* @fq: flush queue
|
|
* @seq: sequences to complete (mask of %REQ_FSEQ_*, can be zero)
|
|
* @error: whether an error occurred
|
|
*
|
|
* @rq just completed @seq part of its flush sequence, record the
|
|
* completion and trigger the next step.
|
|
*
|
|
* CONTEXT:
|
|
* spin_lock_irq(q->queue_lock or fq->mq_flush_lock)
|
|
*
|
|
* RETURNS:
|
|
* %true if requests were added to the dispatch queue, %false otherwise.
|
|
*/
|
|
static bool blk_flush_complete_seq(struct request *rq,
|
|
struct blk_flush_queue *fq,
|
|
unsigned int seq, int error)
|
|
{
|
|
struct request_queue *q = rq->q;
|
|
struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
|
|
bool queued = false, kicked;
|
|
|
|
BUG_ON(rq->flush.seq & seq);
|
|
rq->flush.seq |= seq;
|
|
|
|
if (likely(!error))
|
|
seq = blk_flush_cur_seq(rq);
|
|
else
|
|
seq = REQ_FSEQ_DONE;
|
|
|
|
switch (seq) {
|
|
case REQ_FSEQ_PREFLUSH:
|
|
case REQ_FSEQ_POSTFLUSH:
|
|
/* queue for flush */
|
|
if (list_empty(pending))
|
|
fq->flush_pending_since = jiffies;
|
|
list_move_tail(&rq->flush.list, pending);
|
|
break;
|
|
|
|
case REQ_FSEQ_DATA:
|
|
list_move_tail(&rq->flush.list, &fq->flush_data_in_flight);
|
|
queued = blk_flush_queue_rq(rq, true);
|
|
break;
|
|
|
|
case REQ_FSEQ_DONE:
|
|
/*
|
|
* @rq was previously adjusted by blk_flush_issue() for
|
|
* flush sequencing and may already have gone through the
|
|
* flush data request completion path. Restore @rq for
|
|
* normal completion and end it.
|
|
*/
|
|
BUG_ON(!list_empty(&rq->queuelist));
|
|
list_del_init(&rq->flush.list);
|
|
blk_flush_restore_request(rq);
|
|
if (q->mq_ops)
|
|
blk_mq_end_request(rq, error);
|
|
else
|
|
__blk_end_request_all(rq, error);
|
|
break;
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
kicked = blk_kick_flush(q, fq);
|
|
return kicked | queued;
|
|
}
|
|
|
|
static void flush_end_io(struct request *flush_rq, int error)
|
|
{
|
|
struct request_queue *q = flush_rq->q;
|
|
struct list_head *running;
|
|
bool queued = false;
|
|
struct request *rq, *n;
|
|
unsigned long flags = 0;
|
|
struct blk_flush_queue *fq = blk_get_flush_queue(q, flush_rq->mq_ctx);
|
|
|
|
if (q->mq_ops) {
|
|
struct blk_mq_hw_ctx *hctx;
|
|
|
|
/* release the tag's ownership to the req cloned from */
|
|
spin_lock_irqsave(&fq->mq_flush_lock, flags);
|
|
hctx = q->mq_ops->map_queue(q, flush_rq->mq_ctx->cpu);
|
|
blk_mq_tag_set_rq(hctx, flush_rq->tag, fq->orig_rq);
|
|
flush_rq->tag = -1;
|
|
}
|
|
|
|
running = &fq->flush_queue[fq->flush_running_idx];
|
|
BUG_ON(fq->flush_pending_idx == fq->flush_running_idx);
|
|
|
|
/* account completion of the flush request */
|
|
fq->flush_running_idx ^= 1;
|
|
|
|
if (!q->mq_ops)
|
|
elv_completed_request(q, flush_rq);
|
|
|
|
/* and push the waiting requests to the next stage */
|
|
list_for_each_entry_safe(rq, n, running, flush.list) {
|
|
unsigned int seq = blk_flush_cur_seq(rq);
|
|
|
|
BUG_ON(seq != REQ_FSEQ_PREFLUSH && seq != REQ_FSEQ_POSTFLUSH);
|
|
queued |= blk_flush_complete_seq(rq, fq, seq, error);
|
|
}
|
|
|
|
/*
|
|
* Kick the queue to avoid stall for two cases:
|
|
* 1. Moving a request silently to empty queue_head may stall the
|
|
* queue.
|
|
* 2. When flush request is running in non-queueable queue, the
|
|
* queue is hold. Restart the queue after flush request is finished
|
|
* to avoid stall.
|
|
* This function is called from request completion path and calling
|
|
* directly into request_fn may confuse the driver. Always use
|
|
* kblockd.
|
|
*/
|
|
if (queued || fq->flush_queue_delayed) {
|
|
WARN_ON(q->mq_ops);
|
|
blk_run_queue_async(q);
|
|
}
|
|
fq->flush_queue_delayed = 0;
|
|
if (q->mq_ops)
|
|
spin_unlock_irqrestore(&fq->mq_flush_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* blk_kick_flush - consider issuing flush request
|
|
* @q: request_queue being kicked
|
|
* @fq: flush queue
|
|
*
|
|
* Flush related states of @q have changed, consider issuing flush request.
|
|
* Please read the comment at the top of this file for more info.
|
|
*
|
|
* CONTEXT:
|
|
* spin_lock_irq(q->queue_lock or fq->mq_flush_lock)
|
|
*
|
|
* RETURNS:
|
|
* %true if flush was issued, %false otherwise.
|
|
*/
|
|
static bool blk_kick_flush(struct request_queue *q, struct blk_flush_queue *fq)
|
|
{
|
|
struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
|
|
struct request *first_rq =
|
|
list_first_entry(pending, struct request, flush.list);
|
|
struct request *flush_rq = fq->flush_rq;
|
|
|
|
/* C1 described at the top of this file */
|
|
if (fq->flush_pending_idx != fq->flush_running_idx || list_empty(pending))
|
|
return false;
|
|
|
|
/* C2 and C3 */
|
|
if (!list_empty(&fq->flush_data_in_flight) &&
|
|
time_before(jiffies,
|
|
fq->flush_pending_since + FLUSH_PENDING_TIMEOUT))
|
|
return false;
|
|
|
|
/*
|
|
* Issue flush and toggle pending_idx. This makes pending_idx
|
|
* different from running_idx, which means flush is in flight.
|
|
*/
|
|
fq->flush_pending_idx ^= 1;
|
|
|
|
blk_rq_init(q, flush_rq);
|
|
|
|
/*
|
|
* Borrow tag from the first request since they can't
|
|
* be in flight at the same time. And acquire the tag's
|
|
* ownership for flush req.
|
|
*/
|
|
if (q->mq_ops) {
|
|
struct blk_mq_hw_ctx *hctx;
|
|
|
|
flush_rq->mq_ctx = first_rq->mq_ctx;
|
|
flush_rq->tag = first_rq->tag;
|
|
fq->orig_rq = first_rq;
|
|
|
|
hctx = q->mq_ops->map_queue(q, first_rq->mq_ctx->cpu);
|
|
blk_mq_tag_set_rq(hctx, first_rq->tag, flush_rq);
|
|
}
|
|
|
|
flush_rq->cmd_type = REQ_TYPE_FS;
|
|
flush_rq->cmd_flags = WRITE_FLUSH | REQ_FLUSH_SEQ;
|
|
flush_rq->rq_disk = first_rq->rq_disk;
|
|
flush_rq->end_io = flush_end_io;
|
|
|
|
return blk_flush_queue_rq(flush_rq, false);
|
|
}
|
|
|
|
static void flush_data_end_io(struct request *rq, int error)
|
|
{
|
|
struct request_queue *q = rq->q;
|
|
struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL);
|
|
|
|
/*
|
|
* After populating an empty queue, kick it to avoid stall. Read
|
|
* the comment in flush_end_io().
|
|
*/
|
|
if (blk_flush_complete_seq(rq, fq, REQ_FSEQ_DATA, error))
|
|
blk_run_queue_async(q);
|
|
}
|
|
|
|
static void mq_flush_data_end_io(struct request *rq, int error)
|
|
{
|
|
struct request_queue *q = rq->q;
|
|
struct blk_mq_hw_ctx *hctx;
|
|
struct blk_mq_ctx *ctx = rq->mq_ctx;
|
|
unsigned long flags;
|
|
struct blk_flush_queue *fq = blk_get_flush_queue(q, ctx);
|
|
|
|
hctx = q->mq_ops->map_queue(q, ctx->cpu);
|
|
|
|
/*
|
|
* After populating an empty queue, kick it to avoid stall. Read
|
|
* the comment in flush_end_io().
|
|
*/
|
|
spin_lock_irqsave(&fq->mq_flush_lock, flags);
|
|
if (blk_flush_complete_seq(rq, fq, REQ_FSEQ_DATA, error))
|
|
blk_mq_run_hw_queue(hctx, true);
|
|
spin_unlock_irqrestore(&fq->mq_flush_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* blk_insert_flush - insert a new FLUSH/FUA request
|
|
* @rq: request to insert
|
|
*
|
|
* To be called from __elv_add_request() for %ELEVATOR_INSERT_FLUSH insertions.
|
|
* or __blk_mq_run_hw_queue() to dispatch request.
|
|
* @rq is being submitted. Analyze what needs to be done and put it on the
|
|
* right queue.
|
|
*
|
|
* CONTEXT:
|
|
* spin_lock_irq(q->queue_lock) in !mq case
|
|
*/
|
|
void blk_insert_flush(struct request *rq)
|
|
{
|
|
struct request_queue *q = rq->q;
|
|
unsigned int fflags = q->flush_flags; /* may change, cache */
|
|
unsigned int policy = blk_flush_policy(fflags, rq);
|
|
struct blk_flush_queue *fq = blk_get_flush_queue(q, rq->mq_ctx);
|
|
|
|
/*
|
|
* @policy now records what operations need to be done. Adjust
|
|
* REQ_FLUSH and FUA for the driver.
|
|
*/
|
|
rq->cmd_flags &= ~REQ_FLUSH;
|
|
if (!(fflags & REQ_FUA))
|
|
rq->cmd_flags &= ~REQ_FUA;
|
|
|
|
/*
|
|
* An empty flush handed down from a stacking driver may
|
|
* translate into nothing if the underlying device does not
|
|
* advertise a write-back cache. In this case, simply
|
|
* complete the request.
|
|
*/
|
|
if (!policy) {
|
|
if (q->mq_ops)
|
|
blk_mq_end_request(rq, 0);
|
|
else
|
|
__blk_end_bidi_request(rq, 0, 0, 0);
|
|
return;
|
|
}
|
|
|
|
BUG_ON(rq->bio != rq->biotail); /*assumes zero or single bio rq */
|
|
|
|
/*
|
|
* If there's data but flush is not necessary, the request can be
|
|
* processed directly without going through flush machinery. Queue
|
|
* for normal execution.
|
|
*/
|
|
if ((policy & REQ_FSEQ_DATA) &&
|
|
!(policy & (REQ_FSEQ_PREFLUSH | REQ_FSEQ_POSTFLUSH))) {
|
|
if (q->mq_ops) {
|
|
blk_mq_insert_request(rq, false, false, true);
|
|
} else
|
|
list_add_tail(&rq->queuelist, &q->queue_head);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* @rq should go through flush machinery. Mark it part of flush
|
|
* sequence and submit for further processing.
|
|
*/
|
|
memset(&rq->flush, 0, sizeof(rq->flush));
|
|
INIT_LIST_HEAD(&rq->flush.list);
|
|
rq->cmd_flags |= REQ_FLUSH_SEQ;
|
|
rq->flush.saved_end_io = rq->end_io; /* Usually NULL */
|
|
if (q->mq_ops) {
|
|
rq->end_io = mq_flush_data_end_io;
|
|
|
|
spin_lock_irq(&fq->mq_flush_lock);
|
|
blk_flush_complete_seq(rq, fq, REQ_FSEQ_ACTIONS & ~policy, 0);
|
|
spin_unlock_irq(&fq->mq_flush_lock);
|
|
return;
|
|
}
|
|
rq->end_io = flush_data_end_io;
|
|
|
|
blk_flush_complete_seq(rq, fq, REQ_FSEQ_ACTIONS & ~policy, 0);
|
|
}
|
|
|
|
/**
|
|
* blkdev_issue_flush - queue a flush
|
|
* @bdev: blockdev to issue flush for
|
|
* @gfp_mask: memory allocation flags (for bio_alloc)
|
|
* @error_sector: error sector
|
|
*
|
|
* Description:
|
|
* Issue a flush for the block device in question. Caller can supply
|
|
* room for storing the error offset in case of a flush error, if they
|
|
* wish to. If WAIT flag is not passed then caller may check only what
|
|
* request was pushed in some internal queue for later handling.
|
|
*/
|
|
int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
|
|
sector_t *error_sector)
|
|
{
|
|
struct request_queue *q;
|
|
struct bio *bio;
|
|
int ret = 0;
|
|
|
|
if (bdev->bd_disk == NULL)
|
|
return -ENXIO;
|
|
|
|
q = bdev_get_queue(bdev);
|
|
if (!q)
|
|
return -ENXIO;
|
|
|
|
/*
|
|
* some block devices may not have their queue correctly set up here
|
|
* (e.g. loop device without a backing file) and so issuing a flush
|
|
* here will panic. Ensure there is a request function before issuing
|
|
* the flush.
|
|
*/
|
|
if (!q->make_request_fn)
|
|
return -ENXIO;
|
|
|
|
bio = bio_alloc(gfp_mask, 0);
|
|
bio->bi_bdev = bdev;
|
|
|
|
ret = submit_bio_wait(WRITE_FLUSH, bio);
|
|
|
|
/*
|
|
* The driver must store the error location in ->bi_sector, if
|
|
* it supports it. For non-stacked drivers, this should be
|
|
* copied from blk_rq_pos(rq).
|
|
*/
|
|
if (error_sector)
|
|
*error_sector = bio->bi_iter.bi_sector;
|
|
|
|
bio_put(bio);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(blkdev_issue_flush);
|
|
|
|
struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
|
|
int node, int cmd_size)
|
|
{
|
|
struct blk_flush_queue *fq;
|
|
int rq_sz = sizeof(struct request);
|
|
|
|
fq = kzalloc_node(sizeof(*fq), GFP_KERNEL, node);
|
|
if (!fq)
|
|
goto fail;
|
|
|
|
if (q->mq_ops) {
|
|
spin_lock_init(&fq->mq_flush_lock);
|
|
rq_sz = round_up(rq_sz + cmd_size, cache_line_size());
|
|
}
|
|
|
|
fq->flush_rq = kzalloc_node(rq_sz, GFP_KERNEL, node);
|
|
if (!fq->flush_rq)
|
|
goto fail_rq;
|
|
|
|
INIT_LIST_HEAD(&fq->flush_queue[0]);
|
|
INIT_LIST_HEAD(&fq->flush_queue[1]);
|
|
INIT_LIST_HEAD(&fq->flush_data_in_flight);
|
|
|
|
return fq;
|
|
|
|
fail_rq:
|
|
kfree(fq);
|
|
fail:
|
|
return NULL;
|
|
}
|
|
|
|
void blk_free_flush_queue(struct blk_flush_queue *fq)
|
|
{
|
|
/* bio based request queue hasn't flush queue */
|
|
if (!fq)
|
|
return;
|
|
|
|
kfree(fq->flush_rq);
|
|
kfree(fq);
|
|
}
|