Blame view
block/blk-flush.c
13.1 KB
86db1e297 block: continue l... |
1 |
/* |
4fed947cb block: implement ... |
2 |
* Functions to sequence FLUSH and FUA writes. |
ae1b15396 block: reimplemen... |
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
* * 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 * q->flush_queue[q->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. |
86db1e297 block: continue l... |
65 |
*/ |
ae1b15396 block: reimplemen... |
66 |
|
86db1e297 block: continue l... |
67 68 69 70 |
#include <linux/kernel.h> #include <linux/module.h> #include <linux/bio.h> #include <linux/blkdev.h> |
5a0e3ad6a include cleanup: ... |
71 |
#include <linux/gfp.h> |
86db1e297 block: continue l... |
72 73 |
#include "blk.h" |
4fed947cb block: implement ... |
74 75 |
/* FLUSH/FUA sequences */ enum { |
ae1b15396 block: reimplemen... |
76 77 78 79 80 81 82 83 84 85 86 87 88 |
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, |
4fed947cb block: implement ... |
89 |
}; |
ae1b15396 block: reimplemen... |
90 |
static bool blk_kick_flush(struct request_queue *q); |
28e7d1845 block: drop barri... |
91 |
|
ae1b15396 block: reimplemen... |
92 |
static unsigned int blk_flush_policy(unsigned int fflags, struct request *rq) |
86db1e297 block: continue l... |
93 |
{ |
ae1b15396 block: reimplemen... |
94 |
unsigned int policy = 0; |
86db1e297 block: continue l... |
95 |
|
fa1bf42ff allow blk_flush_p... |
96 97 |
if (blk_rq_sectors(rq)) policy |= REQ_FSEQ_DATA; |
ae1b15396 block: reimplemen... |
98 99 100 |
if (fflags & REQ_FLUSH) { if (rq->cmd_flags & REQ_FLUSH) policy |= REQ_FSEQ_PREFLUSH; |
ae1b15396 block: reimplemen... |
101 102 |
if (!(fflags & REQ_FUA) && (rq->cmd_flags & REQ_FUA)) policy |= REQ_FSEQ_POSTFLUSH; |
28e7d1845 block: drop barri... |
103 |
} |
ae1b15396 block: reimplemen... |
104 |
return policy; |
86db1e297 block: continue l... |
105 |
} |
ae1b15396 block: reimplemen... |
106 |
static unsigned int blk_flush_cur_seq(struct request *rq) |
47f70d5a6 block: kick queue... |
107 |
{ |
ae1b15396 block: reimplemen... |
108 109 |
return 1 << ffz(rq->flush.seq); } |
47f70d5a6 block: kick queue... |
110 |
|
ae1b15396 block: reimplemen... |
111 112 |
static void blk_flush_restore_request(struct request *rq) { |
47f70d5a6 block: kick queue... |
113 |
/* |
ae1b15396 block: reimplemen... |
114 115 116 |
* 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. |
47f70d5a6 block: kick queue... |
117 |
*/ |
ae1b15396 block: reimplemen... |
118 119 120 121 |
rq->bio = rq->biotail; /* make @rq a normal request */ rq->cmd_flags &= ~REQ_FLUSH_SEQ; |
4853abaae block: fix flush ... |
122 |
rq->end_io = rq->flush.saved_end_io; |
47f70d5a6 block: kick queue... |
123 |
} |
ae1b15396 block: reimplemen... |
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 |
/** * blk_flush_complete_seq - complete flush sequence * @rq: FLUSH/FUA request being sequenced * @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) * * RETURNS: * %true if requests were added to the dispatch queue, %false otherwise. */ static bool blk_flush_complete_seq(struct request *rq, unsigned int seq, int error) |
86db1e297 block: continue l... |
141 |
{ |
ae1b15396 block: reimplemen... |
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 |
struct request_queue *q = rq->q; struct list_head *pending = &q->flush_queue[q->flush_pending_idx]; bool queued = false; 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)) q->flush_pending_since = jiffies; list_move_tail(&rq->flush.list, pending); break; case REQ_FSEQ_DATA: list_move_tail(&rq->flush.list, &q->flush_data_in_flight); list_add(&rq->queuelist, &q->queue_head); queued = 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); __blk_end_request_all(rq, error); break; default: BUG(); } return blk_kick_flush(q) | queued; |
86db1e297 block: continue l... |
187 |
} |
ae1b15396 block: reimplemen... |
188 |
static void flush_end_io(struct request *flush_rq, int error) |
86db1e297 block: continue l... |
189 |
{ |
ae1b15396 block: reimplemen... |
190 191 |
struct request_queue *q = flush_rq->q; struct list_head *running = &q->flush_queue[q->flush_running_idx]; |
ae1b15396 block: reimplemen... |
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 |
bool queued = false; struct request *rq, *n; BUG_ON(q->flush_pending_idx == q->flush_running_idx); /* account completion of the flush request */ q->flush_running_idx ^= 1; 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, seq, error); } |
47f70d5a6 block: kick queue... |
208 |
/* |
3ac0cc450 block: hold queue... |
209 210 211 212 213 214 215 216 217 |
* 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. |
47f70d5a6 block: kick queue... |
218 |
*/ |
3ac0cc450 block: hold queue... |
219 |
if (queued || q->flush_queue_delayed) |
24ecfbe27 block: add blk_ru... |
220 |
blk_run_queue_async(q); |
3ac0cc450 block: hold queue... |
221 |
q->flush_queue_delayed = 0; |
86db1e297 block: continue l... |
222 |
} |
ae1b15396 block: reimplemen... |
223 224 225 226 227 228 229 230 231 232 233 234 235 236 |
/** * blk_kick_flush - consider issuing flush request * @q: request_queue being kicked * * 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) * * RETURNS: * %true if flush was issued, %false otherwise. */ static bool blk_kick_flush(struct request_queue *q) |
86db1e297 block: continue l... |
237 |
{ |
ae1b15396 block: reimplemen... |
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 |
struct list_head *pending = &q->flush_queue[q->flush_pending_idx]; struct request *first_rq = list_first_entry(pending, struct request, flush.list); /* C1 described at the top of this file */ if (q->flush_pending_idx != q->flush_running_idx || list_empty(pending)) return false; /* C2 and C3 */ if (!list_empty(&q->flush_data_in_flight) && time_before(jiffies, q->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. */ blk_rq_init(q, &q->flush_rq); q->flush_rq.cmd_type = REQ_TYPE_FS; q->flush_rq.cmd_flags = WRITE_FLUSH | REQ_FLUSH_SEQ; q->flush_rq.rq_disk = first_rq->rq_disk; q->flush_rq.end_io = flush_end_io; q->flush_pending_idx ^= 1; |
53d63e6b0 block: make the f... |
263 |
list_add_tail(&q->flush_rq.queuelist, &q->queue_head); |
ae1b15396 block: reimplemen... |
264 |
return true; |
86db1e297 block: continue l... |
265 |
} |
ae1b15396 block: reimplemen... |
266 |
static void flush_data_end_io(struct request *rq, int error) |
86db1e297 block: continue l... |
267 |
{ |
ae1b15396 block: reimplemen... |
268 |
struct request_queue *q = rq->q; |
ae1b15396 block: reimplemen... |
269 |
|
e83a46bbb Merge branch 'for... |
270 271 272 273 |
/* * After populating an empty queue, kick it to avoid stall. Read * the comment in flush_end_io(). */ |
73c101011 block: initial pa... |
274 |
if (blk_flush_complete_seq(rq, REQ_FSEQ_DATA, error)) |
24ecfbe27 block: add blk_ru... |
275 |
blk_run_queue_async(q); |
86db1e297 block: continue l... |
276 |
} |
ae1b15396 block: reimplemen... |
277 278 279 280 |
/** * blk_insert_flush - insert a new FLUSH/FUA request * @rq: request to insert * |
b710a4805 block: get rid of... |
281 |
* To be called from __elv_add_request() for %ELEVATOR_INSERT_FLUSH insertions. |
ae1b15396 block: reimplemen... |
282 283 284 285 286 287 288 |
* @rq is being submitted. Analyze what needs to be done and put it on the * right queue. * * CONTEXT: * spin_lock_irq(q->queue_lock) */ void blk_insert_flush(struct request *rq) |
86db1e297 block: continue l... |
289 |
{ |
ae1b15396 block: reimplemen... |
290 291 292 |
struct request_queue *q = rq->q; unsigned int fflags = q->flush_flags; /* may change, cache */ unsigned int policy = blk_flush_policy(fflags, rq); |
86db1e297 block: continue l... |
293 |
|
ae1b15396 block: reimplemen... |
294 295 296 297 298 299 300 301 302 |
/* * @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; /* |
4853abaae block: fix flush ... |
303 304 305 306 307 308 309 310 311 |
* 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) { __blk_end_bidi_request(rq, 0, 0, 0); return; } |
834f9f61a blk-flush: fix in... |
312 |
BUG_ON(rq->bio != rq->biotail); /*assumes zero or single bio rq */ |
4853abaae block: fix flush ... |
313 314 |
/* |
ae1b15396 block: reimplemen... |
315 316 317 318 319 320 |
* 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))) { |
53d63e6b0 block: make the f... |
321 |
list_add_tail(&rq->queuelist, &q->queue_head); |
ae1b15396 block: reimplemen... |
322 |
return; |
28e7d1845 block: drop barri... |
323 |
} |
cde4c406d block: simplify q... |
324 |
|
ae1b15396 block: reimplemen... |
325 326 327 328 329 330 |
/* * @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); |
414b4ff5e block: add REQ_FL... |
331 |
rq->cmd_flags |= REQ_FLUSH_SEQ; |
4853abaae block: fix flush ... |
332 |
rq->flush.saved_end_io = rq->end_io; /* Usually NULL */ |
ae1b15396 block: reimplemen... |
333 334 335 |
rq->end_io = flush_data_end_io; blk_flush_complete_seq(rq, REQ_FSEQ_ACTIONS & ~policy, 0); |
86db1e297 block: continue l... |
336 |
} |
ae1b15396 block: reimplemen... |
337 338 339 340 341 342 343 344 345 346 347 |
/** * blk_abort_flushes - @q is being aborted, abort flush requests * @q: request_queue being aborted * * To be called from elv_abort_queue(). @q is being aborted. Prepare all * FLUSH/FUA requests for abortion. * * CONTEXT: * spin_lock_irq(q->queue_lock) */ void blk_abort_flushes(struct request_queue *q) |
86db1e297 block: continue l... |
348 |
{ |
ae1b15396 block: reimplemen... |
349 350 |
struct request *rq, *n; int i; |
28e7d1845 block: drop barri... |
351 |
|
4fed947cb block: implement ... |
352 |
/* |
ae1b15396 block: reimplemen... |
353 354 |
* Requests in flight for data are already owned by the dispatch * queue or the device driver. Just restore for normal completion. |
4fed947cb block: implement ... |
355 |
*/ |
ae1b15396 block: reimplemen... |
356 357 358 |
list_for_each_entry_safe(rq, n, &q->flush_data_in_flight, flush.list) { list_del_init(&rq->flush.list); blk_flush_restore_request(rq); |
4fed947cb block: implement ... |
359 |
} |
28e7d1845 block: drop barri... |
360 |
|
4fed947cb block: implement ... |
361 |
/* |
ae1b15396 block: reimplemen... |
362 363 |
* We need to give away requests on flush queues. Restore for * normal completion and put them on the dispatch queue. |
4fed947cb block: implement ... |
364 |
*/ |
ae1b15396 block: reimplemen... |
365 366 367 368 369 370 371 |
for (i = 0; i < ARRAY_SIZE(q->flush_queue); i++) { list_for_each_entry_safe(rq, n, &q->flush_queue[i], flush.list) { list_del_init(&rq->flush.list); blk_flush_restore_request(rq); list_add_tail(&rq->queuelist, &q->queue_head); } |
28e7d1845 block: drop barri... |
372 |
} |
86db1e297 block: continue l... |
373 |
} |
d391a2dda block: use REQ_FL... |
374 |
static void bio_end_flush(struct bio *bio, int err) |
86db1e297 block: continue l... |
375 |
{ |
d391a2dda block: use REQ_FL... |
376 |
if (err) |
86db1e297 block: continue l... |
377 |
clear_bit(BIO_UPTODATE, &bio->bi_flags); |
f17e232e9 blkdev: allow asy... |
378 379 380 |
if (bio->bi_private) complete(bio->bi_private); bio_put(bio); |
86db1e297 block: continue l... |
381 382 383 384 385 |
} /** * blkdev_issue_flush - queue a flush * @bdev: blockdev to issue flush for |
fbd9b09a1 blkdev: generaliz... |
386 |
* @gfp_mask: memory allocation flags (for bio_alloc) |
86db1e297 block: continue l... |
387 388 389 390 391 |
* @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 |
f17e232e9 blkdev: allow asy... |
392 393 |
* wish to. If WAIT flag is not passed then caller may check only what * request was pushed in some internal queue for later handling. |
86db1e297 block: continue l... |
394 |
*/ |
fbd9b09a1 blkdev: generaliz... |
395 |
int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask, |
dd3932edd block: remove BLK... |
396 |
sector_t *error_sector) |
86db1e297 block: continue l... |
397 398 399 400 |
{ DECLARE_COMPLETION_ONSTACK(wait); struct request_queue *q; struct bio *bio; |
fbd9b09a1 blkdev: generaliz... |
401 |
int ret = 0; |
86db1e297 block: continue l... |
402 403 404 405 406 407 408 |
if (bdev->bd_disk == NULL) return -ENXIO; q = bdev_get_queue(bdev); if (!q) return -ENXIO; |
f10d9f617 blkdev: check for... |
409 410 411 412 |
/* * 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 |
d391a2dda block: use REQ_FL... |
413 |
* the flush. |
f10d9f617 blkdev: check for... |
414 415 416 |
*/ if (!q->make_request_fn) return -ENXIO; |
fbd9b09a1 blkdev: generaliz... |
417 |
bio = bio_alloc(gfp_mask, 0); |
d391a2dda block: use REQ_FL... |
418 |
bio->bi_end_io = bio_end_flush; |
86db1e297 block: continue l... |
419 |
bio->bi_bdev = bdev; |
dd3932edd block: remove BLK... |
420 |
bio->bi_private = &wait; |
86db1e297 block: continue l... |
421 |
|
f17e232e9 blkdev: allow asy... |
422 |
bio_get(bio); |
d391a2dda block: use REQ_FL... |
423 |
submit_bio(WRITE_FLUSH, bio); |
dd3932edd block: remove BLK... |
424 425 426 427 428 429 430 431 432 |
wait_for_completion(&wait); /* * 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_sector; |
86db1e297 block: continue l... |
433 |
|
d391a2dda block: use REQ_FL... |
434 |
if (!bio_flagged(bio, BIO_UPTODATE)) |
86db1e297 block: continue l... |
435 436 437 438 439 |
ret = -EIO; bio_put(bio); return ret; } |
86db1e297 block: continue l... |
440 |
EXPORT_SYMBOL(blkdev_issue_flush); |