Blame view
block/blk-core.c
67.8 KB
1da177e4c
|
1 |
/* |
1da177e4c
|
2 3 4 5 |
* Copyright (C) 1991, 1992 Linus Torvalds * Copyright (C) 1994, Karl Keyte: Added support for disk statistics * Elevator latency, (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE * Queue request tables / lock, selectable elevator, Jens Axboe <axboe@suse.de> |
6728cb0e6
|
6 7 |
* kernel-doc documentation started by NeilBrown <neilb@cse.unsw.edu.au> * - July2000 |
1da177e4c
|
8 9 10 11 12 13 |
* bio rewrite, highmem i/o, etc, Jens Axboe <axboe@suse.de> - may 2001 */ /* * This handles all read/write requests to block devices */ |
1da177e4c
|
14 15 16 17 18 19 20 21 22 23 |
#include <linux/kernel.h> #include <linux/module.h> #include <linux/backing-dev.h> #include <linux/bio.h> #include <linux/blkdev.h> #include <linux/highmem.h> #include <linux/mm.h> #include <linux/kernel_stat.h> #include <linux/string.h> #include <linux/init.h> |
1da177e4c
|
24 25 26 27 |
#include <linux/completion.h> #include <linux/slab.h> #include <linux/swap.h> #include <linux/writeback.h> |
faccbd4b2
|
28 |
#include <linux/task_io_accounting_ops.h> |
c17bb4951
|
29 |
#include <linux/fault-inject.h> |
55782138e
|
30 31 32 |
#define CREATE_TRACE_POINTS #include <trace/events/block.h> |
1da177e4c
|
33 |
|
8324aa91d
|
34 |
#include "blk.h" |
0bfc24559
|
35 |
EXPORT_TRACEPOINT_SYMBOL_GPL(block_remap); |
b0da3f0da
|
36 |
EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_remap); |
55782138e
|
37 |
EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_complete); |
0bfc24559
|
38 |
|
165125e1e
|
39 |
static int __make_request(struct request_queue *q, struct bio *bio); |
1da177e4c
|
40 41 42 43 |
/* * For the allocated request tables */ |
5ece6c52e
|
44 |
static struct kmem_cache *request_cachep; |
1da177e4c
|
45 46 47 48 |
/* * For queue allocation */ |
6728cb0e6
|
49 |
struct kmem_cache *blk_requestq_cachep; |
1da177e4c
|
50 51 |
/* |
1da177e4c
|
52 53 |
* Controlling structure to kblockd */ |
ff856bad6
|
54 |
static struct workqueue_struct *kblockd_workqueue; |
1da177e4c
|
55 |
|
26b8256e2
|
56 57 |
static void drive_stat_acct(struct request *rq, int new_io) { |
28f13702f
|
58 |
struct hd_struct *part; |
26b8256e2
|
59 |
int rw = rq_data_dir(rq); |
c99590591
|
60 |
int cpu; |
26b8256e2
|
61 |
|
c2553b584
|
62 |
if (!blk_do_io_stat(rq)) |
26b8256e2
|
63 |
return; |
074a7aca7
|
64 |
cpu = part_stat_lock(); |
83096ebf1
|
65 |
part = disk_map_sector_rcu(rq->rq_disk, blk_rq_pos(rq)); |
c99590591
|
66 |
|
28f13702f
|
67 |
if (!new_io) |
074a7aca7
|
68 |
part_stat_inc(cpu, part, merges[rw]); |
28f13702f
|
69 |
else { |
074a7aca7
|
70 |
part_round_stats(cpu, part); |
316d315bf
|
71 |
part_inc_in_flight(part, rw); |
26b8256e2
|
72 |
} |
e71bf0d0e
|
73 |
|
074a7aca7
|
74 |
part_stat_unlock(); |
26b8256e2
|
75 |
} |
8324aa91d
|
76 |
void blk_queue_congestion_threshold(struct request_queue *q) |
1da177e4c
|
77 78 79 80 81 82 83 84 85 86 87 88 89 |
{ int nr; nr = q->nr_requests - (q->nr_requests / 8) + 1; if (nr > q->nr_requests) nr = q->nr_requests; q->nr_congestion_on = nr; nr = q->nr_requests - (q->nr_requests / 8) - (q->nr_requests / 16) - 1; if (nr < 1) nr = 1; q->nr_congestion_off = nr; } |
1da177e4c
|
90 91 92 93 94 95 96 97 98 99 100 101 |
/** * blk_get_backing_dev_info - get the address of a queue's backing_dev_info * @bdev: device * * Locates the passed device's request queue and returns the address of its * backing_dev_info * * Will return NULL if the request queue cannot be located. */ struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev) { struct backing_dev_info *ret = NULL; |
165125e1e
|
102 |
struct request_queue *q = bdev_get_queue(bdev); |
1da177e4c
|
103 104 105 106 107 |
if (q) ret = &q->backing_dev_info; return ret; } |
1da177e4c
|
108 |
EXPORT_SYMBOL(blk_get_backing_dev_info); |
2a4aa30c5
|
109 |
void blk_rq_init(struct request_queue *q, struct request *rq) |
1da177e4c
|
110 |
{ |
1afb20f30
|
111 |
memset(rq, 0, sizeof(*rq)); |
1da177e4c
|
112 |
INIT_LIST_HEAD(&rq->queuelist); |
242f9dcb8
|
113 |
INIT_LIST_HEAD(&rq->timeout_list); |
c7c22e4d5
|
114 |
rq->cpu = -1; |
63a713867
|
115 |
rq->q = q; |
a2dec7b36
|
116 |
rq->__sector = (sector_t) -1; |
2e662b65f
|
117 118 |
INIT_HLIST_NODE(&rq->hash); RB_CLEAR_NODE(&rq->rb_node); |
d7e3c3249
|
119 |
rq->cmd = rq->__cmd; |
e2494e1b4
|
120 |
rq->cmd_len = BLK_MAX_CDB; |
63a713867
|
121 |
rq->tag = -1; |
1da177e4c
|
122 |
rq->ref_count = 1; |
b243ddcbe
|
123 |
rq->start_time = jiffies; |
9195291e5
|
124 |
set_start_time_ns(rq); |
1da177e4c
|
125 |
} |
2a4aa30c5
|
126 |
EXPORT_SYMBOL(blk_rq_init); |
1da177e4c
|
127 |
|
5bb23a688
|
128 129 |
static void req_bio_endio(struct request *rq, struct bio *bio, unsigned int nbytes, int error) |
1da177e4c
|
130 |
{ |
165125e1e
|
131 |
struct request_queue *q = rq->q; |
797e7dbbe
|
132 |
|
5bb23a688
|
133 134 135 136 137 |
if (&q->bar_rq != rq) { if (error) clear_bit(BIO_UPTODATE, &bio->bi_flags); else if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) error = -EIO; |
797e7dbbe
|
138 |
|
5bb23a688
|
139 |
if (unlikely(nbytes > bio->bi_size)) { |
6728cb0e6
|
140 141 |
printk(KERN_ERR "%s: want %u bytes done, %u left ", |
24c03d47d
|
142 |
__func__, nbytes, bio->bi_size); |
5bb23a688
|
143 144 |
nbytes = bio->bi_size; } |
797e7dbbe
|
145 |
|
08bafc034
|
146 147 |
if (unlikely(rq->cmd_flags & REQ_QUIET)) set_bit(BIO_QUIET, &bio->bi_flags); |
5bb23a688
|
148 149 |
bio->bi_size -= nbytes; bio->bi_sector += (nbytes >> 9); |
7ba1ba12e
|
150 151 152 |
if (bio_integrity(bio)) bio_integrity_advance(bio, nbytes); |
5bb23a688
|
153 |
if (bio->bi_size == 0) |
6712ecf8f
|
154 |
bio_endio(bio, error); |
5bb23a688
|
155 156 157 158 159 160 161 162 163 |
} else { /* * Okay, this is the barrier request in progress, just * record the error; */ if (error && !q->orderr) q->orderr = error; } |
1da177e4c
|
164 |
} |
1da177e4c
|
165 |
|
1da177e4c
|
166 167 168 |
void blk_dump_rq_flags(struct request *rq, char *msg) { int bit; |
6728cb0e6
|
169 170 |
printk(KERN_INFO "%s: dev %s: type=%x, flags=%x ", msg, |
4aff5e233
|
171 172 |
rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->cmd_type, rq->cmd_flags); |
1da177e4c
|
173 |
|
83096ebf1
|
174 175 176 177 |
printk(KERN_INFO " sector %llu, nr/cnr %u/%u ", (unsigned long long)blk_rq_pos(rq), blk_rq_sectors(rq), blk_rq_cur_sectors(rq)); |
731ec497e
|
178 179 |
printk(KERN_INFO " bio %p, biotail %p, buffer %p, len %u ", |
2e46e8b27
|
180 |
rq->bio, rq->biotail, rq->buffer, blk_rq_bytes(rq)); |
1da177e4c
|
181 |
|
4aff5e233
|
182 |
if (blk_pc_request(rq)) { |
6728cb0e6
|
183 |
printk(KERN_INFO " cdb: "); |
d34c87e4b
|
184 |
for (bit = 0; bit < BLK_MAX_CDB; bit++) |
1da177e4c
|
185 186 187 188 189 |
printk("%02x ", rq->cmd[bit]); printk(" "); } } |
1da177e4c
|
190 |
EXPORT_SYMBOL(blk_dump_rq_flags); |
1da177e4c
|
191 192 193 194 195 196 197 198 |
/* * "plug" the device if there are no outstanding requests: this will * force the transfer to start only after we have put all the requests * on the list. * * This is called with interrupts off and no requests on the queue and * with the queue lock held. */ |
165125e1e
|
199 |
void blk_plug_device(struct request_queue *q) |
1da177e4c
|
200 201 202 203 204 205 206 |
{ WARN_ON(!irqs_disabled()); /* * don't plug a stopped queue, it must be paired with blk_start_queue() * which will restart the queueing */ |
7daac4902
|
207 |
if (blk_queue_stopped(q)) |
1da177e4c
|
208 |
return; |
e48ec6900
|
209 |
if (!queue_flag_test_and_set(QUEUE_FLAG_PLUGGED, q)) { |
1da177e4c
|
210 |
mod_timer(&q->unplug_timer, jiffies + q->unplug_delay); |
5f3ea37c7
|
211 |
trace_block_plug(q); |
2056a782f
|
212 |
} |
1da177e4c
|
213 |
} |
1da177e4c
|
214 |
EXPORT_SYMBOL(blk_plug_device); |
6c5e0c4d5
|
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 |
/** * blk_plug_device_unlocked - plug a device without queue lock held * @q: The &struct request_queue to plug * * Description: * Like @blk_plug_device(), but grabs the queue lock and disables * interrupts. **/ void blk_plug_device_unlocked(struct request_queue *q) { unsigned long flags; spin_lock_irqsave(q->queue_lock, flags); blk_plug_device(q); spin_unlock_irqrestore(q->queue_lock, flags); } EXPORT_SYMBOL(blk_plug_device_unlocked); |
1da177e4c
|
232 233 234 235 |
/* * remove the queue from the plugged list, if present. called with * queue lock held and interrupts disabled. */ |
165125e1e
|
236 |
int blk_remove_plug(struct request_queue *q) |
1da177e4c
|
237 238 |
{ WARN_ON(!irqs_disabled()); |
e48ec6900
|
239 |
if (!queue_flag_test_and_clear(QUEUE_FLAG_PLUGGED, q)) |
1da177e4c
|
240 241 242 243 244 |
return 0; del_timer(&q->unplug_timer); return 1; } |
1da177e4c
|
245 246 247 248 249 |
EXPORT_SYMBOL(blk_remove_plug); /* * remove the plug and let it rip.. */ |
165125e1e
|
250 |
void __generic_unplug_device(struct request_queue *q) |
1da177e4c
|
251 |
{ |
7daac4902
|
252 |
if (unlikely(blk_queue_stopped(q))) |
1da177e4c
|
253 |
return; |
a31a97381
|
254 |
if (!blk_remove_plug(q) && !blk_queue_nonrot(q)) |
1da177e4c
|
255 |
return; |
22e2c507c
|
256 |
q->request_fn(q); |
1da177e4c
|
257 |
} |
1da177e4c
|
258 259 260 |
/** * generic_unplug_device - fire a request queue |
165125e1e
|
261 |
* @q: The &struct request_queue in question |
1da177e4c
|
262 263 264 265 266 267 268 269 |
* * Description: * Linux uses plugging to build bigger requests queues before letting * the device have at them. If a queue is plugged, the I/O scheduler * is still adding and merging requests on the queue. Once the queue * gets unplugged, the request_fn defined for the queue is invoked and * transfers started. **/ |
165125e1e
|
270 |
void generic_unplug_device(struct request_queue *q) |
1da177e4c
|
271 |
{ |
dbaf2c003
|
272 273 274 275 276 |
if (blk_queue_plugged(q)) { spin_lock_irq(q->queue_lock); __generic_unplug_device(q); spin_unlock_irq(q->queue_lock); } |
1da177e4c
|
277 278 279 280 281 282 |
} EXPORT_SYMBOL(generic_unplug_device); static void blk_backing_dev_unplug(struct backing_dev_info *bdi, struct page *page) { |
165125e1e
|
283 |
struct request_queue *q = bdi->unplug_io_data; |
1da177e4c
|
284 |
|
2ad8b1ef1
|
285 |
blk_unplug(q); |
1da177e4c
|
286 |
} |
86db1e297
|
287 |
void blk_unplug_work(struct work_struct *work) |
1da177e4c
|
288 |
{ |
165125e1e
|
289 290 |
struct request_queue *q = container_of(work, struct request_queue, unplug_work); |
1da177e4c
|
291 |
|
5f3ea37c7
|
292 |
trace_block_unplug_io(q); |
1da177e4c
|
293 294 |
q->unplug_fn(q); } |
86db1e297
|
295 |
void blk_unplug_timeout(unsigned long data) |
1da177e4c
|
296 |
{ |
165125e1e
|
297 |
struct request_queue *q = (struct request_queue *)data; |
1da177e4c
|
298 |
|
5f3ea37c7
|
299 |
trace_block_unplug_timer(q); |
18887ad91
|
300 |
kblockd_schedule_work(q, &q->unplug_work); |
1da177e4c
|
301 |
} |
2ad8b1ef1
|
302 303 304 305 306 307 |
void blk_unplug(struct request_queue *q) { /* * devices don't necessarily have an ->unplug_fn defined */ if (q->unplug_fn) { |
5f3ea37c7
|
308 |
trace_block_unplug_io(q); |
2ad8b1ef1
|
309 310 311 312 |
q->unplug_fn(q); } } EXPORT_SYMBOL(blk_unplug); |
1da177e4c
|
313 314 |
/** * blk_start_queue - restart a previously stopped queue |
165125e1e
|
315 |
* @q: The &struct request_queue in question |
1da177e4c
|
316 317 318 319 320 321 |
* * Description: * blk_start_queue() will clear the stop flag on the queue, and call * the request_fn for the queue if it was in a stopped state when * entered. Also see blk_stop_queue(). Queue lock must be held. **/ |
165125e1e
|
322 |
void blk_start_queue(struct request_queue *q) |
1da177e4c
|
323 |
{ |
a038e2536
|
324 |
WARN_ON(!irqs_disabled()); |
75ad23bc0
|
325 |
queue_flag_clear(QUEUE_FLAG_STOPPED, q); |
a538cd03b
|
326 |
__blk_run_queue(q); |
1da177e4c
|
327 |
} |
1da177e4c
|
328 329 330 331 |
EXPORT_SYMBOL(blk_start_queue); /** * blk_stop_queue - stop a queue |
165125e1e
|
332 |
* @q: The &struct request_queue in question |
1da177e4c
|
333 334 335 336 337 338 339 340 341 342 343 |
* * Description: * The Linux block layer assumes that a block driver will consume all * entries on the request queue when the request_fn strategy is called. * Often this will not happen, because of hardware limitations (queue * depth settings). If a device driver gets a 'queue full' response, * or if it simply chooses not to queue more I/O at one point, it can * call this function to prevent the request_fn from being called until * the driver has signalled it's ready to go again. This happens by calling * blk_start_queue() to restart queue operations. Queue lock must be held. **/ |
165125e1e
|
344 |
void blk_stop_queue(struct request_queue *q) |
1da177e4c
|
345 346 |
{ blk_remove_plug(q); |
75ad23bc0
|
347 |
queue_flag_set(QUEUE_FLAG_STOPPED, q); |
1da177e4c
|
348 349 350 351 352 353 354 355 356 357 358 359 |
} EXPORT_SYMBOL(blk_stop_queue); /** * blk_sync_queue - cancel any pending callbacks on a queue * @q: the queue * * Description: * The block layer may perform asynchronous callback activity * on a queue, such as calling the unplug function after a timeout. * A block device may call blk_sync_queue to ensure that any * such activity is cancelled, thus allowing it to release resources |
59c51591a
|
360 |
* that the callbacks might use. The caller must already have made sure |
1da177e4c
|
361 362 363 364 365 366 367 |
* that its ->make_request_fn will not re-add plugging prior to calling * this function. * */ void blk_sync_queue(struct request_queue *q) { del_timer_sync(&q->unplug_timer); |
70ed28b92
|
368 |
del_timer_sync(&q->timeout); |
64d01dc9e
|
369 |
cancel_work_sync(&q->unplug_work); |
1da177e4c
|
370 371 372 373 |
} EXPORT_SYMBOL(blk_sync_queue); /** |
80a4b58e3
|
374 |
* __blk_run_queue - run a single device queue |
1da177e4c
|
375 |
* @q: The queue to run |
80a4b58e3
|
376 377 378 379 380 |
* * Description: * See @blk_run_queue. This variant must be called with the queue lock * held and interrupts disabled. * |
1da177e4c
|
381 |
*/ |
75ad23bc0
|
382 |
void __blk_run_queue(struct request_queue *q) |
1da177e4c
|
383 |
{ |
1da177e4c
|
384 |
blk_remove_plug(q); |
dac07ec12
|
385 |
|
a538cd03b
|
386 387 388 389 390 |
if (unlikely(blk_queue_stopped(q))) return; if (elv_queue_empty(q)) return; |
dac07ec12
|
391 392 393 394 |
/* * Only recurse once to avoid overrunning the stack, let the unplug * handling reinvoke the handler shortly if we already got there. */ |
a538cd03b
|
395 396 397 398 399 400 401 |
if (!queue_flag_test_and_set(QUEUE_FLAG_REENTER, q)) { q->request_fn(q); queue_flag_clear(QUEUE_FLAG_REENTER, q); } else { queue_flag_set(QUEUE_FLAG_PLUGGED, q); kblockd_schedule_work(q, &q->unplug_work); } |
75ad23bc0
|
402 403 |
} EXPORT_SYMBOL(__blk_run_queue); |
dac07ec12
|
404 |
|
75ad23bc0
|
405 406 407 |
/** * blk_run_queue - run a single device queue * @q: The queue to run |
80a4b58e3
|
408 409 410 |
* * Description: * Invoke request handling on this queue, if it has pending work to do. |
a7f557923
|
411 |
* May be used to restart queueing when a request has completed. |
75ad23bc0
|
412 413 414 415 416 417 418 |
*/ void blk_run_queue(struct request_queue *q) { unsigned long flags; spin_lock_irqsave(q->queue_lock, flags); __blk_run_queue(q); |
1da177e4c
|
419 420 421 |
spin_unlock_irqrestore(q->queue_lock, flags); } EXPORT_SYMBOL(blk_run_queue); |
165125e1e
|
422 |
void blk_put_queue(struct request_queue *q) |
483f4afc4
|
423 424 425 |
{ kobject_put(&q->kobj); } |
483f4afc4
|
426 |
|
6728cb0e6
|
427 |
void blk_cleanup_queue(struct request_queue *q) |
483f4afc4
|
428 |
{ |
e3335de94
|
429 430 431 432 433 434 435 |
/* * We know we have process context here, so we can be a little * cautious and ensure that pending block actions on this device * are done before moving on. Going into this function, we should * not have processes doing IO to this device. */ blk_sync_queue(q); |
31373d09d
|
436 |
del_timer_sync(&q->backing_dev_info.laptop_mode_wb_timer); |
483f4afc4
|
437 |
mutex_lock(&q->sysfs_lock); |
75ad23bc0
|
438 |
queue_flag_set_unlocked(QUEUE_FLAG_DEAD, q); |
483f4afc4
|
439 440 441 442 443 444 445 |
mutex_unlock(&q->sysfs_lock); if (q->elevator) elevator_exit(q->elevator); blk_put_queue(q); } |
1da177e4c
|
446 |
EXPORT_SYMBOL(blk_cleanup_queue); |
165125e1e
|
447 |
static int blk_init_free_list(struct request_queue *q) |
1da177e4c
|
448 449 |
{ struct request_list *rl = &q->rq; |
1abec4fdb
|
450 451 |
if (unlikely(rl->rq_pool)) return 0; |
1faa16d22
|
452 453 |
rl->count[BLK_RW_SYNC] = rl->count[BLK_RW_ASYNC] = 0; rl->starved[BLK_RW_SYNC] = rl->starved[BLK_RW_ASYNC] = 0; |
cb98fc8bb
|
454 |
rl->elvpriv = 0; |
1faa16d22
|
455 456 |
init_waitqueue_head(&rl->wait[BLK_RW_SYNC]); init_waitqueue_head(&rl->wait[BLK_RW_ASYNC]); |
1da177e4c
|
457 |
|
1946089a1
|
458 459 |
rl->rq_pool = mempool_create_node(BLKDEV_MIN_RQ, mempool_alloc_slab, mempool_free_slab, request_cachep, q->node); |
1da177e4c
|
460 461 462 463 464 465 |
if (!rl->rq_pool) return -ENOMEM; return 0; } |
165125e1e
|
466 |
struct request_queue *blk_alloc_queue(gfp_t gfp_mask) |
1da177e4c
|
467 |
{ |
1946089a1
|
468 469 470 |
return blk_alloc_queue_node(gfp_mask, -1); } EXPORT_SYMBOL(blk_alloc_queue); |
1da177e4c
|
471 |
|
165125e1e
|
472 |
struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id) |
1946089a1
|
473 |
{ |
165125e1e
|
474 |
struct request_queue *q; |
e0bf68dde
|
475 |
int err; |
1946089a1
|
476 |
|
8324aa91d
|
477 |
q = kmem_cache_alloc_node(blk_requestq_cachep, |
94f6030ca
|
478 |
gfp_mask | __GFP_ZERO, node_id); |
1da177e4c
|
479 480 |
if (!q) return NULL; |
e0bf68dde
|
481 482 |
q->backing_dev_info.unplug_io_fn = blk_backing_dev_unplug; q->backing_dev_info.unplug_io_data = q; |
0989a025d
|
483 484 485 486 |
q->backing_dev_info.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE; q->backing_dev_info.state = 0; q->backing_dev_info.capabilities = BDI_CAP_MAP_COPY; |
d993831fa
|
487 |
q->backing_dev_info.name = "block"; |
0989a025d
|
488 |
|
e0bf68dde
|
489 490 |
err = bdi_init(&q->backing_dev_info); if (err) { |
8324aa91d
|
491 |
kmem_cache_free(blk_requestq_cachep, q); |
e0bf68dde
|
492 493 |
return NULL; } |
31373d09d
|
494 495 |
setup_timer(&q->backing_dev_info.laptop_mode_wb_timer, laptop_mode_timer_fn, (unsigned long) q); |
1da177e4c
|
496 |
init_timer(&q->unplug_timer); |
242f9dcb8
|
497 498 |
setup_timer(&q->timeout, blk_rq_timed_out_timer, (unsigned long) q); INIT_LIST_HEAD(&q->timeout_list); |
713ada9ba
|
499 |
INIT_WORK(&q->unplug_work, blk_unplug_work); |
483f4afc4
|
500 |
|
8324aa91d
|
501 |
kobject_init(&q->kobj, &blk_queue_ktype); |
1da177e4c
|
502 |
|
483f4afc4
|
503 |
mutex_init(&q->sysfs_lock); |
e7e72bf64
|
504 |
spin_lock_init(&q->__queue_lock); |
483f4afc4
|
505 |
|
1da177e4c
|
506 507 |
return q; } |
1946089a1
|
508 |
EXPORT_SYMBOL(blk_alloc_queue_node); |
1da177e4c
|
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 |
/** * blk_init_queue - prepare a request queue for use with a block device * @rfn: The function to be called to process requests that have been * placed on the queue. * @lock: Request queue spin lock * * Description: * If a block device wishes to use the standard request handling procedures, * which sorts requests and coalesces adjacent requests, then it must * call blk_init_queue(). The function @rfn will be called when there * are requests on the queue that need to be processed. If the device * supports plugging, then @rfn may not be called immediately when requests * are available on the queue, but may be called at some time later instead. * Plugged queues are generally unplugged when a buffer belonging to one * of the requests on the queue is needed, or due to memory pressure. * * @rfn is not required, or even expected, to remove all requests off the * queue, but only as many as it can handle at a time. If it does leave * requests on the queue, it is responsible for arranging that the requests * get dealt with eventually. * * The queue spin lock must be held while manipulating the requests on the |
a038e2536
|
532 533 |
* request queue; this lock will be taken also from interrupt context, so irq * disabling is needed for it. |
1da177e4c
|
534 |
* |
710027a48
|
535 |
* Function returns a pointer to the initialized request queue, or %NULL if |
1da177e4c
|
536 537 538 539 540 541 |
* it didn't succeed. * * Note: * blk_init_queue() must be paired with a blk_cleanup_queue() call * when the block device is deactivated (such as at module unload). **/ |
1946089a1
|
542 |
|
165125e1e
|
543 |
struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock) |
1da177e4c
|
544 |
{ |
1946089a1
|
545 546 547 |
return blk_init_queue_node(rfn, lock, -1); } EXPORT_SYMBOL(blk_init_queue); |
165125e1e
|
548 |
struct request_queue * |
1946089a1
|
549 550 |
blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id) { |
c86d1b8ae
|
551 |
struct request_queue *uninit_q, *q; |
1da177e4c
|
552 |
|
c86d1b8ae
|
553 554 555 556 557 558 559 560 561 |
uninit_q = blk_alloc_queue_node(GFP_KERNEL, node_id); if (!uninit_q) return NULL; q = blk_init_allocated_queue_node(uninit_q, rfn, lock, node_id); if (!q) blk_cleanup_queue(uninit_q); return q; |
01effb0dc
|
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 |
} EXPORT_SYMBOL(blk_init_queue_node); struct request_queue * blk_init_allocated_queue(struct request_queue *q, request_fn_proc *rfn, spinlock_t *lock) { return blk_init_allocated_queue_node(q, rfn, lock, -1); } EXPORT_SYMBOL(blk_init_allocated_queue); struct request_queue * blk_init_allocated_queue_node(struct request_queue *q, request_fn_proc *rfn, spinlock_t *lock, int node_id) { |
1da177e4c
|
577 578 |
if (!q) return NULL; |
1946089a1
|
579 |
q->node = node_id; |
c86d1b8ae
|
580 |
if (blk_init_free_list(q)) |
8669aafdb
|
581 |
return NULL; |
1da177e4c
|
582 583 |
q->request_fn = rfn; |
1da177e4c
|
584 585 |
q->prep_rq_fn = NULL; q->unplug_fn = generic_unplug_device; |
bc58ba946
|
586 |
q->queue_flags = QUEUE_FLAG_DEFAULT; |
1da177e4c
|
587 |
q->queue_lock = lock; |
f3b144aa7
|
588 589 590 |
/* * This also sets hw/phys segments, boundary and size */ |
1da177e4c
|
591 |
blk_queue_make_request(q, __make_request); |
1da177e4c
|
592 |
|
44ec95425
|
593 |
q->sg_reserved_size = INT_MAX; |
1da177e4c
|
594 595 596 597 598 599 600 |
/* * all done */ if (!elevator_init(q, NULL)) { blk_queue_congestion_threshold(q); return q; } |
1da177e4c
|
601 602 |
return NULL; } |
01effb0dc
|
603 |
EXPORT_SYMBOL(blk_init_allocated_queue_node); |
1da177e4c
|
604 |
|
165125e1e
|
605 |
int blk_get_queue(struct request_queue *q) |
1da177e4c
|
606 |
{ |
fde6ad224
|
607 |
if (likely(!test_bit(QUEUE_FLAG_DEAD, &q->queue_flags))) { |
483f4afc4
|
608 |
kobject_get(&q->kobj); |
1da177e4c
|
609 610 611 612 613 |
return 0; } return 1; } |
1da177e4c
|
614 |
|
165125e1e
|
615 |
static inline void blk_free_request(struct request_queue *q, struct request *rq) |
1da177e4c
|
616 |
{ |
4aff5e233
|
617 |
if (rq->cmd_flags & REQ_ELVPRIV) |
cb98fc8bb
|
618 |
elv_put_request(q, rq); |
1da177e4c
|
619 620 |
mempool_free(rq, q->rq.rq_pool); } |
1ea25ecb7
|
621 |
static struct request * |
42dad7647
|
622 |
blk_alloc_request(struct request_queue *q, int flags, int priv, gfp_t gfp_mask) |
1da177e4c
|
623 624 625 626 627 |
{ struct request *rq = mempool_alloc(q->rq.rq_pool, gfp_mask); if (!rq) return NULL; |
2a4aa30c5
|
628 |
blk_rq_init(q, rq); |
1afb20f30
|
629 |
|
42dad7647
|
630 |
rq->cmd_flags = flags | REQ_ALLOCED; |
1da177e4c
|
631 |
|
cb98fc8bb
|
632 |
if (priv) { |
cb78b285c
|
633 |
if (unlikely(elv_set_request(q, rq, gfp_mask))) { |
cb98fc8bb
|
634 635 636 |
mempool_free(rq, q->rq.rq_pool); return NULL; } |
4aff5e233
|
637 |
rq->cmd_flags |= REQ_ELVPRIV; |
cb98fc8bb
|
638 |
} |
1da177e4c
|
639 |
|
cb98fc8bb
|
640 |
return rq; |
1da177e4c
|
641 642 643 644 645 646 |
} /* * ioc_batching returns true if the ioc is a valid batching request and * should be given priority access to a request. */ |
165125e1e
|
647 |
static inline int ioc_batching(struct request_queue *q, struct io_context *ioc) |
1da177e4c
|
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 |
{ if (!ioc) return 0; /* * Make sure the process is able to allocate at least 1 request * even if the batch times out, otherwise we could theoretically * lose wakeups. */ return ioc->nr_batch_requests == q->nr_batching || (ioc->nr_batch_requests > 0 && time_before(jiffies, ioc->last_waited + BLK_BATCH_TIME)); } /* * ioc_set_batching sets ioc to be a new "batcher" if it is not one. This * will cause the process to be a "batcher" on all queues in the system. This * is the behaviour we want though - once it gets a wakeup it should be given * a nice run. */ |
165125e1e
|
668 |
static void ioc_set_batching(struct request_queue *q, struct io_context *ioc) |
1da177e4c
|
669 670 671 672 673 674 675 |
{ if (!ioc || ioc_batching(q, ioc)) return; ioc->nr_batch_requests = q->nr_batching; ioc->last_waited = jiffies; } |
1faa16d22
|
676 |
static void __freed_request(struct request_queue *q, int sync) |
1da177e4c
|
677 678 |
{ struct request_list *rl = &q->rq; |
1faa16d22
|
679 680 |
if (rl->count[sync] < queue_congestion_off_threshold(q)) blk_clear_queue_congested(q, sync); |
1da177e4c
|
681 |
|
1faa16d22
|
682 683 684 |
if (rl->count[sync] + 1 <= q->nr_requests) { if (waitqueue_active(&rl->wait[sync])) wake_up(&rl->wait[sync]); |
1da177e4c
|
685 |
|
1faa16d22
|
686 |
blk_clear_queue_full(q, sync); |
1da177e4c
|
687 688 689 690 691 692 693 |
} } /* * A request has just been released. Account for it, update the full and * congestion status, wake up any waiters. Called under q->queue_lock. */ |
1faa16d22
|
694 |
static void freed_request(struct request_queue *q, int sync, int priv) |
1da177e4c
|
695 696 |
{ struct request_list *rl = &q->rq; |
1faa16d22
|
697 |
rl->count[sync]--; |
cb98fc8bb
|
698 699 |
if (priv) rl->elvpriv--; |
1da177e4c
|
700 |
|
1faa16d22
|
701 |
__freed_request(q, sync); |
1da177e4c
|
702 |
|
1faa16d22
|
703 704 |
if (unlikely(rl->starved[sync ^ 1])) __freed_request(q, sync ^ 1); |
1da177e4c
|
705 |
} |
1da177e4c
|
706 |
/* |
d6344532a
|
707 708 709 |
* Get a free request, queue_lock must be held. * Returns NULL on failure, with queue_lock held. * Returns !NULL on success, with queue_lock *not held*. |
1da177e4c
|
710 |
*/ |
165125e1e
|
711 |
static struct request *get_request(struct request_queue *q, int rw_flags, |
7749a8d42
|
712 |
struct bio *bio, gfp_t gfp_mask) |
1da177e4c
|
713 714 715 |
{ struct request *rq = NULL; struct request_list *rl = &q->rq; |
88ee5ef15
|
716 |
struct io_context *ioc = NULL; |
1faa16d22
|
717 |
const bool is_sync = rw_is_sync(rw_flags) != 0; |
88ee5ef15
|
718 |
int may_queue, priv; |
7749a8d42
|
719 |
may_queue = elv_may_queue(q, rw_flags); |
88ee5ef15
|
720 721 |
if (may_queue == ELV_MQUEUE_NO) goto rq_starved; |
1faa16d22
|
722 723 |
if (rl->count[is_sync]+1 >= queue_congestion_on_threshold(q)) { if (rl->count[is_sync]+1 >= q->nr_requests) { |
b5deef901
|
724 |
ioc = current_io_context(GFP_ATOMIC, q->node); |
88ee5ef15
|
725 726 727 728 729 730 |
/* * The queue will fill after this allocation, so set * it as full, and mark this process as "batching". * This process will be allowed to complete a batch of * requests, others will be blocked. */ |
1faa16d22
|
731 |
if (!blk_queue_full(q, is_sync)) { |
88ee5ef15
|
732 |
ioc_set_batching(q, ioc); |
1faa16d22
|
733 |
blk_set_queue_full(q, is_sync); |
88ee5ef15
|
734 735 736 737 738 739 740 741 742 743 744 |
} else { if (may_queue != ELV_MQUEUE_MUST && !ioc_batching(q, ioc)) { /* * The queue is full and the allocating * process is not a "batcher", and not * exempted by the IO scheduler */ goto out; } } |
1da177e4c
|
745 |
} |
1faa16d22
|
746 |
blk_set_queue_congested(q, is_sync); |
1da177e4c
|
747 |
} |
082cf69eb
|
748 749 750 751 752 |
/* * Only allow batching queuers to allocate up to 50% over the defined * limit of requests, otherwise we could have thousands of requests * allocated with any setting of ->nr_requests */ |
1faa16d22
|
753 |
if (rl->count[is_sync] >= (3 * q->nr_requests / 2)) |
082cf69eb
|
754 |
goto out; |
fd782a4a9
|
755 |
|
1faa16d22
|
756 757 |
rl->count[is_sync]++; rl->starved[is_sync] = 0; |
cb98fc8bb
|
758 |
|
64521d1a3
|
759 |
priv = !test_bit(QUEUE_FLAG_ELVSWITCH, &q->queue_flags); |
cb98fc8bb
|
760 761 |
if (priv) rl->elvpriv++; |
42dad7647
|
762 763 |
if (blk_queue_io_stat(q)) rw_flags |= REQ_IO_STAT; |
1da177e4c
|
764 |
spin_unlock_irq(q->queue_lock); |
7749a8d42
|
765 |
rq = blk_alloc_request(q, rw_flags, priv, gfp_mask); |
88ee5ef15
|
766 |
if (unlikely(!rq)) { |
1da177e4c
|
767 768 769 770 771 772 773 774 |
/* * Allocation failed presumably due to memory. Undo anything * we might have messed up. * * Allocating task should really be put onto the front of the * wait queue, but this is pretty rare. */ spin_lock_irq(q->queue_lock); |
1faa16d22
|
775 |
freed_request(q, is_sync, priv); |
1da177e4c
|
776 777 778 779 780 781 782 783 784 |
/* * in the very unlikely event that allocation failed and no * requests for this direction was pending, mark us starved * so that freeing of a request in the other direction will * notice us. another possible fix would be to split the * rq mempool into READ and WRITE */ rq_starved: |
1faa16d22
|
785 786 |
if (unlikely(rl->count[is_sync] == 0)) rl->starved[is_sync] = 1; |
1da177e4c
|
787 |
|
1da177e4c
|
788 789 |
goto out; } |
88ee5ef15
|
790 791 792 793 794 795 |
/* * ioc may be NULL here, and ioc_batching will be false. That's * OK, if the queue is under the request limit then requests need * not count toward the nr_batch_requests limit. There will always * be some limit enforced by BLK_BATCH_TIME. */ |
1da177e4c
|
796 797 |
if (ioc_batching(q, ioc)) ioc->nr_batch_requests--; |
6728cb0e6
|
798 |
|
1faa16d22
|
799 |
trace_block_getrq(q, bio, rw_flags & 1); |
1da177e4c
|
800 |
out: |
1da177e4c
|
801 802 803 804 805 806 |
return rq; } /* * No available requests for this queue, unplug the device and wait for some * requests to become available. |
d6344532a
|
807 808 |
* * Called with q->queue_lock held, and returns with it unlocked. |
1da177e4c
|
809 |
*/ |
165125e1e
|
810 |
static struct request *get_request_wait(struct request_queue *q, int rw_flags, |
22e2c507c
|
811 |
struct bio *bio) |
1da177e4c
|
812 |
{ |
1faa16d22
|
813 |
const bool is_sync = rw_is_sync(rw_flags) != 0; |
1da177e4c
|
814 |
struct request *rq; |
7749a8d42
|
815 |
rq = get_request(q, rw_flags, bio, GFP_NOIO); |
450991bc1
|
816 817 |
while (!rq) { DEFINE_WAIT(wait); |
05caf8dbc
|
818 |
struct io_context *ioc; |
1da177e4c
|
819 |
struct request_list *rl = &q->rq; |
1faa16d22
|
820 |
prepare_to_wait_exclusive(&rl->wait[is_sync], &wait, |
1da177e4c
|
821 |
TASK_UNINTERRUPTIBLE); |
1faa16d22
|
822 |
trace_block_sleeprq(q, bio, rw_flags & 1); |
1da177e4c
|
823 |
|
05caf8dbc
|
824 825 826 |
__generic_unplug_device(q); spin_unlock_irq(q->queue_lock); io_schedule(); |
1da177e4c
|
827 |
|
05caf8dbc
|
828 829 830 831 832 833 834 835 |
/* * After sleeping, we become a "batching" process and * will be able to allocate at least one request, and * up to a big batch of them for a small period time. * See ioc_batching, ioc_set_batching */ ioc = current_io_context(GFP_NOIO, q->node); ioc_set_batching(q, ioc); |
d6344532a
|
836 |
|
05caf8dbc
|
837 |
spin_lock_irq(q->queue_lock); |
1faa16d22
|
838 |
finish_wait(&rl->wait[is_sync], &wait); |
05caf8dbc
|
839 840 841 |
rq = get_request(q, rw_flags, bio, GFP_NOIO); }; |
1da177e4c
|
842 843 844 |
return rq; } |
165125e1e
|
845 |
struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask) |
1da177e4c
|
846 847 848 849 |
{ struct request *rq; BUG_ON(rw != READ && rw != WRITE); |
d6344532a
|
850 851 |
spin_lock_irq(q->queue_lock); if (gfp_mask & __GFP_WAIT) { |
22e2c507c
|
852 |
rq = get_request_wait(q, rw, NULL); |
d6344532a
|
853 |
} else { |
22e2c507c
|
854 |
rq = get_request(q, rw, NULL, gfp_mask); |
d6344532a
|
855 856 857 858 |
if (!rq) spin_unlock_irq(q->queue_lock); } /* q->queue_lock is unlocked at this point */ |
1da177e4c
|
859 860 861 |
return rq; } |
1da177e4c
|
862 863 864 |
EXPORT_SYMBOL(blk_get_request); /** |
79eb63e9e
|
865 |
* blk_make_request - given a bio, allocate a corresponding struct request. |
8ebf97560
|
866 |
* @q: target request queue |
79eb63e9e
|
867 868 |
* @bio: The bio describing the memory mappings that will be submitted for IO. * It may be a chained-bio properly constructed by block/bio layer. |
8ebf97560
|
869 |
* @gfp_mask: gfp flags to be used for memory allocation |
dc72ef4ae
|
870 |
* |
79eb63e9e
|
871 872 873 874 |
* blk_make_request is the parallel of generic_make_request for BLOCK_PC * type commands. Where the struct request needs to be farther initialized by * the caller. It is passed a &struct bio, which describes the memory info of * the I/O transfer. |
dc72ef4ae
|
875 |
* |
79eb63e9e
|
876 877 878 879 880 881 882 883 884 |
* The caller of blk_make_request must make sure that bi_io_vec * are set to describe the memory buffers. That bio_data_dir() will return * the needed direction of the request. (And all bio's in the passed bio-chain * are properly set accordingly) * * If called under none-sleepable conditions, mapped bio buffers must not * need bouncing, by calling the appropriate masked or flagged allocator, * suitable for the target device. Otherwise the call to blk_queue_bounce will * BUG. |
53674ac5a
|
885 886 887 888 889 890 891 892 893 |
* * WARNING: When allocating/cloning a bio-chain, careful consideration should be * given to how you allocate bios. In particular, you cannot use __GFP_WAIT for * anything but the first bio in the chain. Otherwise you risk waiting for IO * completion of a bio that hasn't been submitted yet, thus resulting in a * deadlock. Alternatively bios should be allocated using bio_kmalloc() instead * of bio_alloc(), as that avoids the mempool deadlock. * If possible a big IO should be split into smaller parts when allocation * fails. Partial allocation should not be an error, or you risk a live-lock. |
dc72ef4ae
|
894 |
*/ |
79eb63e9e
|
895 896 |
struct request *blk_make_request(struct request_queue *q, struct bio *bio, gfp_t gfp_mask) |
dc72ef4ae
|
897 |
{ |
79eb63e9e
|
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 |
struct request *rq = blk_get_request(q, bio_data_dir(bio), gfp_mask); if (unlikely(!rq)) return ERR_PTR(-ENOMEM); for_each_bio(bio) { struct bio *bounce_bio = bio; int ret; blk_queue_bounce(q, &bounce_bio); ret = blk_rq_append_bio(q, rq, bounce_bio); if (unlikely(ret)) { blk_put_request(rq); return ERR_PTR(ret); } } return rq; |
dc72ef4ae
|
916 |
} |
79eb63e9e
|
917 |
EXPORT_SYMBOL(blk_make_request); |
dc72ef4ae
|
918 919 |
/** |
1da177e4c
|
920 921 922 923 924 925 926 927 928 |
* blk_requeue_request - put a request back on queue * @q: request queue where request should be inserted * @rq: request to be inserted * * Description: * Drivers often keep queueing requests until the hardware cannot accept * more, when that condition happens we need to put the request back * on the queue. Must be called with queue lock held. */ |
165125e1e
|
929 |
void blk_requeue_request(struct request_queue *q, struct request *rq) |
1da177e4c
|
930 |
{ |
242f9dcb8
|
931 932 |
blk_delete_timer(rq); blk_clear_rq_complete(rq); |
5f3ea37c7
|
933 |
trace_block_rq_requeue(q, rq); |
2056a782f
|
934 |
|
1da177e4c
|
935 936 |
if (blk_rq_tagged(rq)) blk_queue_end_tag(q, rq); |
ba396a6c1
|
937 |
BUG_ON(blk_queued_rq(rq)); |
1da177e4c
|
938 939 |
elv_requeue_request(q, rq); } |
1da177e4c
|
940 941 942 |
EXPORT_SYMBOL(blk_requeue_request); /** |
710027a48
|
943 |
* blk_insert_request - insert a special request into a request queue |
1da177e4c
|
944 945 946 947 |
* @q: request queue where request should be inserted * @rq: request to be inserted * @at_head: insert request at head or tail of queue * @data: private data |
1da177e4c
|
948 949 950 951 952 |
* * Description: * Many block devices need to execute commands asynchronously, so they don't * block the whole kernel from preemption during request execution. This is * accomplished normally by inserting aritficial requests tagged as |
710027a48
|
953 954 |
* REQ_TYPE_SPECIAL in to the corresponding request queue, and letting them * be scheduled for actual execution by the request queue. |
1da177e4c
|
955 956 957 958 959 960 |
* * We have the option of inserting the head or the tail of the queue. * Typically we use the tail for new ioctls and so forth. We use the head * of the queue for things like a QUEUE_FULL message from a device, or a * host that is unable to accept a particular command. */ |
165125e1e
|
961 |
void blk_insert_request(struct request_queue *q, struct request *rq, |
867d1191f
|
962 |
int at_head, void *data) |
1da177e4c
|
963 |
{ |
867d1191f
|
964 |
int where = at_head ? ELEVATOR_INSERT_FRONT : ELEVATOR_INSERT_BACK; |
1da177e4c
|
965 966 967 968 969 970 971 |
unsigned long flags; /* * tell I/O scheduler that this isn't a regular read/write (ie it * must not attempt merges on this) and that it acts as a soft * barrier */ |
4aff5e233
|
972 |
rq->cmd_type = REQ_TYPE_SPECIAL; |
1da177e4c
|
973 974 975 976 977 978 979 980 |
rq->special = data; spin_lock_irqsave(q->queue_lock, flags); /* * If command is tagged, release the tag */ |
867d1191f
|
981 982 |
if (blk_rq_tagged(rq)) blk_queue_end_tag(q, rq); |
1da177e4c
|
983 |
|
b238b3d4b
|
984 |
drive_stat_acct(rq, 1); |
867d1191f
|
985 |
__elv_add_request(q, rq, where, 0); |
a7f557923
|
986 |
__blk_run_queue(q); |
1da177e4c
|
987 988 |
spin_unlock_irqrestore(q->queue_lock, flags); } |
1da177e4c
|
989 |
EXPORT_SYMBOL(blk_insert_request); |
1da177e4c
|
990 991 992 993 994 |
/* * add-request adds a request to the linked list. * queue lock is held and interrupts disabled, as we muck with the * request queue list. */ |
6728cb0e6
|
995 |
static inline void add_request(struct request_queue *q, struct request *req) |
1da177e4c
|
996 |
{ |
b238b3d4b
|
997 |
drive_stat_acct(req, 1); |
1da177e4c
|
998 |
|
1da177e4c
|
999 1000 1001 1002 1003 1004 |
/* * elevator indicated where it wants this request to be * inserted at elevator_merge time */ __elv_add_request(q, req, ELEVATOR_INSERT_SORT, 0); } |
6728cb0e6
|
1005 |
|
074a7aca7
|
1006 1007 1008 1009 1010 |
static void part_round_stats_single(int cpu, struct hd_struct *part, unsigned long now) { if (now == part->stamp) return; |
316d315bf
|
1011 |
if (part_in_flight(part)) { |
074a7aca7
|
1012 |
__part_stat_add(cpu, part, time_in_queue, |
316d315bf
|
1013 |
part_in_flight(part) * (now - part->stamp)); |
074a7aca7
|
1014 1015 1016 1017 1018 1019 |
__part_stat_add(cpu, part, io_ticks, (now - part->stamp)); } part->stamp = now; } /** |
496aa8a98
|
1020 1021 1022 |
* part_round_stats() - Round off the performance stats on a struct disk_stats. * @cpu: cpu number for stats access * @part: target partition |
1da177e4c
|
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 |
* * The average IO queue length and utilisation statistics are maintained * by observing the current state of the queue length and the amount of * time it has been in this state for. * * Normally, that accounting is done on IO completion, but that can result * in more than a second's worth of IO being accounted for within any one * second, leading to >100% utilisation. To deal with that, we call this * function to do a round-off before returning the results when reading * /proc/diskstats. This accounts immediately for all queue usage up to * the current jiffies and restarts the counters again. */ |
c99590591
|
1035 |
void part_round_stats(int cpu, struct hd_struct *part) |
6f2576af5
|
1036 1037 |
{ unsigned long now = jiffies; |
074a7aca7
|
1038 1039 1040 |
if (part->partno) part_round_stats_single(cpu, &part_to_disk(part)->part0, now); part_round_stats_single(cpu, part, now); |
6f2576af5
|
1041 |
} |
074a7aca7
|
1042 |
EXPORT_SYMBOL_GPL(part_round_stats); |
6f2576af5
|
1043 |
|
1da177e4c
|
1044 1045 1046 |
/* * queue lock must be held */ |
165125e1e
|
1047 |
void __blk_put_request(struct request_queue *q, struct request *req) |
1da177e4c
|
1048 |
{ |
1da177e4c
|
1049 1050 1051 1052 |
if (unlikely(!q)) return; if (unlikely(--req->ref_count)) return; |
8922e16cf
|
1053 |
elv_completed_request(q, req); |
1cd96c242
|
1054 1055 |
/* this is a bio leak */ WARN_ON(req->bio != NULL); |
1da177e4c
|
1056 1057 1058 1059 |
/* * Request may not have originated from ll_rw_blk. if not, * it didn't come out of our reserved rq pools */ |
49171e5c6
|
1060 |
if (req->cmd_flags & REQ_ALLOCED) { |
1faa16d22
|
1061 |
int is_sync = rq_is_sync(req) != 0; |
4aff5e233
|
1062 |
int priv = req->cmd_flags & REQ_ELVPRIV; |
1da177e4c
|
1063 |
|
1da177e4c
|
1064 |
BUG_ON(!list_empty(&req->queuelist)); |
9817064b6
|
1065 |
BUG_ON(!hlist_unhashed(&req->hash)); |
1da177e4c
|
1066 1067 |
blk_free_request(q, req); |
1faa16d22
|
1068 |
freed_request(q, is_sync, priv); |
1da177e4c
|
1069 1070 |
} } |
6e39b69e7
|
1071 |
EXPORT_SYMBOL_GPL(__blk_put_request); |
1da177e4c
|
1072 1073 |
void blk_put_request(struct request *req) { |
8922e16cf
|
1074 |
unsigned long flags; |
165125e1e
|
1075 |
struct request_queue *q = req->q; |
8922e16cf
|
1076 |
|
52a93ba81
|
1077 1078 1079 |
spin_lock_irqsave(q->queue_lock, flags); __blk_put_request(q, req); spin_unlock_irqrestore(q->queue_lock, flags); |
1da177e4c
|
1080 |
} |
1da177e4c
|
1081 |
EXPORT_SYMBOL(blk_put_request); |
86db1e297
|
1082 |
void init_request_from_bio(struct request *req, struct bio *bio) |
52d9e6753
|
1083 |
{ |
c7c22e4d5
|
1084 |
req->cpu = bio->bi_comp_cpu; |
4aff5e233
|
1085 |
req->cmd_type = REQ_TYPE_FS; |
52d9e6753
|
1086 1087 |
/* |
a82afdfcb
|
1088 1089 |
* Inherit FAILFAST from bio (for read-ahead, and explicit * FAILFAST). FAILFAST flags are identical for req and bio. |
52d9e6753
|
1090 |
*/ |
1f98a13f6
|
1091 |
if (bio_rw_flagged(bio, BIO_RW_AHEAD)) |
a82afdfcb
|
1092 1093 1094 |
req->cmd_flags |= REQ_FAILFAST_MASK; else req->cmd_flags |= bio->bi_rw & REQ_FAILFAST_MASK; |
52d9e6753
|
1095 |
|
1f98a13f6
|
1096 |
if (unlikely(bio_rw_flagged(bio, BIO_RW_DISCARD))) { |
e17fc0a1c
|
1097 |
req->cmd_flags |= REQ_DISCARD; |
1f98a13f6
|
1098 |
if (bio_rw_flagged(bio, BIO_RW_BARRIER)) |
e17fc0a1c
|
1099 |
req->cmd_flags |= REQ_SOFTBARRIER; |
1f98a13f6
|
1100 |
} else if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER))) |
e4025f6c2
|
1101 |
req->cmd_flags |= REQ_HARDBARRIER; |
52d9e6753
|
1102 |
|
1f98a13f6
|
1103 |
if (bio_rw_flagged(bio, BIO_RW_SYNCIO)) |
4aff5e233
|
1104 |
req->cmd_flags |= REQ_RW_SYNC; |
1f98a13f6
|
1105 |
if (bio_rw_flagged(bio, BIO_RW_META)) |
5404bc7a8
|
1106 |
req->cmd_flags |= REQ_RW_META; |
1f98a13f6
|
1107 |
if (bio_rw_flagged(bio, BIO_RW_NOIDLE)) |
aeb6fafb8
|
1108 |
req->cmd_flags |= REQ_NOIDLE; |
b31dc66a5
|
1109 |
|
52d9e6753
|
1110 |
req->errors = 0; |
a2dec7b36
|
1111 |
req->__sector = bio->bi_sector; |
52d9e6753
|
1112 |
req->ioprio = bio_prio(bio); |
bc1c56fde
|
1113 |
blk_rq_bio_prep(req->q, req, bio); |
52d9e6753
|
1114 |
} |
644b2d99b
|
1115 1116 1117 1118 1119 1120 |
/* * Only disabling plugging for non-rotational devices if it does tagging * as well, otherwise we do need the proper merging */ static inline bool queue_should_plug(struct request_queue *q) { |
79da0644a
|
1121 |
return !(blk_queue_nonrot(q) && blk_queue_tagged(q)); |
644b2d99b
|
1122 |
} |
165125e1e
|
1123 |
static int __make_request(struct request_queue *q, struct bio *bio) |
1da177e4c
|
1124 |
{ |
450991bc1
|
1125 |
struct request *req; |
2e46e8b27
|
1126 1127 |
int el_ret; unsigned int bytes = bio->bi_size; |
51da90fcb
|
1128 |
const unsigned short prio = bio_prio(bio); |
1f98a13f6
|
1129 1130 |
const bool sync = bio_rw_flagged(bio, BIO_RW_SYNCIO); const bool unplug = bio_rw_flagged(bio, BIO_RW_UNPLUG); |
80a761fd3
|
1131 |
const unsigned int ff = bio->bi_rw & REQ_FAILFAST_MASK; |
7749a8d42
|
1132 |
int rw_flags; |
1da177e4c
|
1133 |
|
6cafb12dc
|
1134 |
if (bio_rw_flagged(bio, BIO_RW_BARRIER) && |
db64f680b
|
1135 1136 1137 1138 |
(q->next_ordered == QUEUE_ORDERED_NONE)) { bio_endio(bio, -EOPNOTSUPP); return 0; } |
1da177e4c
|
1139 1140 1141 1142 1143 1144 |
/* * low level driver can indicate that it wants pages above a * certain limit bounced to low memory (ie for highmem, or even * ISA dma in theory) */ blk_queue_bounce(q, &bio); |
1da177e4c
|
1145 |
spin_lock_irq(q->queue_lock); |
1f98a13f6
|
1146 |
if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER)) || elv_queue_empty(q)) |
1da177e4c
|
1147 1148 1149 1150 |
goto get_rq; el_ret = elv_merge(q, &req, bio); switch (el_ret) { |
6728cb0e6
|
1151 1152 |
case ELEVATOR_BACK_MERGE: BUG_ON(!rq_mergeable(req)); |
1da177e4c
|
1153 |
|
6728cb0e6
|
1154 1155 |
if (!ll_back_merge_fn(q, req, bio)) break; |
1da177e4c
|
1156 |
|
5f3ea37c7
|
1157 |
trace_block_bio_backmerge(q, bio); |
2056a782f
|
1158 |
|
80a761fd3
|
1159 1160 |
if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff) blk_rq_set_mixed_merge(req); |
6728cb0e6
|
1161 1162 |
req->biotail->bi_next = bio; req->biotail = bio; |
a2dec7b36
|
1163 |
req->__data_len += bytes; |
6728cb0e6
|
1164 |
req->ioprio = ioprio_best(req->ioprio, prio); |
ab780f1ec
|
1165 1166 |
if (!blk_rq_cpu_valid(req)) req->cpu = bio->bi_comp_cpu; |
6728cb0e6
|
1167 |
drive_stat_acct(req, 0); |
812d40264
|
1168 |
elv_bio_merged(q, req, bio); |
6728cb0e6
|
1169 1170 1171 |
if (!attempt_back_merge(q, req)) elv_merged_request(q, req, el_ret); goto out; |
1da177e4c
|
1172 |
|
6728cb0e6
|
1173 1174 |
case ELEVATOR_FRONT_MERGE: BUG_ON(!rq_mergeable(req)); |
1da177e4c
|
1175 |
|
6728cb0e6
|
1176 1177 |
if (!ll_front_merge_fn(q, req, bio)) break; |
1da177e4c
|
1178 |
|
5f3ea37c7
|
1179 |
trace_block_bio_frontmerge(q, bio); |
2056a782f
|
1180 |
|
80a761fd3
|
1181 1182 1183 1184 1185 |
if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff) { blk_rq_set_mixed_merge(req); req->cmd_flags &= ~REQ_FAILFAST_MASK; req->cmd_flags |= ff; } |
6728cb0e6
|
1186 1187 |
bio->bi_next = req->bio; req->bio = bio; |
1da177e4c
|
1188 |
|
6728cb0e6
|
1189 1190 1191 1192 1193 1194 |
/* * may not be valid. if the low level driver said * it didn't need a bounce buffer then it better * not touch req->buffer either... */ req->buffer = bio_data(bio); |
a2dec7b36
|
1195 1196 |
req->__sector = bio->bi_sector; req->__data_len += bytes; |
6728cb0e6
|
1197 |
req->ioprio = ioprio_best(req->ioprio, prio); |
ab780f1ec
|
1198 1199 |
if (!blk_rq_cpu_valid(req)) req->cpu = bio->bi_comp_cpu; |
6728cb0e6
|
1200 |
drive_stat_acct(req, 0); |
812d40264
|
1201 |
elv_bio_merged(q, req, bio); |
6728cb0e6
|
1202 1203 1204 1205 1206 1207 1208 |
if (!attempt_front_merge(q, req)) elv_merged_request(q, req, el_ret); goto out; /* ELV_NO_MERGE: elevator says don't/can't merge. */ default: ; |
1da177e4c
|
1209 |
} |
450991bc1
|
1210 |
get_rq: |
1da177e4c
|
1211 |
/* |
7749a8d42
|
1212 1213 1214 1215 1216 1217 1218 1219 1220 |
* This sync check and mask will be re-done in init_request_from_bio(), * but we need to set it earlier to expose the sync flag to the * rq allocator and io schedulers. */ rw_flags = bio_data_dir(bio); if (sync) rw_flags |= REQ_RW_SYNC; /* |
450991bc1
|
1221 |
* Grab a free request. This is might sleep but can not fail. |
d6344532a
|
1222 |
* Returns with the queue unlocked. |
450991bc1
|
1223 |
*/ |
7749a8d42
|
1224 |
req = get_request_wait(q, rw_flags, bio); |
d6344532a
|
1225 |
|
450991bc1
|
1226 1227 1228 1229 1230 |
/* * After dropping the lock and possibly sleeping here, our request * may now be mergeable after it had proven unmergeable (above). * We don't worry about that case for efficiency. It won't happen * often, and the elevators are able to handle it. |
1da177e4c
|
1231 |
*/ |
52d9e6753
|
1232 |
init_request_from_bio(req, bio); |
1da177e4c
|
1233 |
|
450991bc1
|
1234 |
spin_lock_irq(q->queue_lock); |
c7c22e4d5
|
1235 1236 1237 |
if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags) || bio_flagged(bio, BIO_CPU_AFFINE)) req->cpu = blk_cpu_to_group(smp_processor_id()); |
644b2d99b
|
1238 |
if (queue_should_plug(q) && elv_queue_empty(q)) |
450991bc1
|
1239 |
blk_plug_device(q); |
1da177e4c
|
1240 1241 |
add_request(q, req); out: |
644b2d99b
|
1242 |
if (unplug || !queue_should_plug(q)) |
1da177e4c
|
1243 |
__generic_unplug_device(q); |
1da177e4c
|
1244 1245 |
spin_unlock_irq(q->queue_lock); return 0; |
1da177e4c
|
1246 1247 1248 1249 1250 1251 1252 1253 |
} /* * If bio->bi_dev is a partition, remap the location */ static inline void blk_partition_remap(struct bio *bio) { struct block_device *bdev = bio->bi_bdev; |
bf2de6f5a
|
1254 |
if (bio_sectors(bio) && bdev != bdev->bd_contains) { |
1da177e4c
|
1255 |
struct hd_struct *p = bdev->bd_part; |
1da177e4c
|
1256 1257 |
bio->bi_sector += p->start_sect; bio->bi_bdev = bdev->bd_contains; |
c7149d6bc
|
1258 |
|
5f3ea37c7
|
1259 |
trace_block_remap(bdev_get_queue(bio->bi_bdev), bio, |
22a7c31a9
|
1260 |
bdev->bd_dev, |
c7149d6bc
|
1261 |
bio->bi_sector - p->start_sect); |
1da177e4c
|
1262 1263 |
} } |
1da177e4c
|
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 |
static void handle_bad_sector(struct bio *bio) { char b[BDEVNAME_SIZE]; printk(KERN_INFO "attempt to access beyond end of device "); printk(KERN_INFO "%s: rw=%ld, want=%Lu, limit=%Lu ", bdevname(bio->bi_bdev, b), bio->bi_rw, (unsigned long long)bio->bi_sector + bio_sectors(bio), (long long)(bio->bi_bdev->bd_inode->i_size >> 9)); set_bit(BIO_EOF, &bio->bi_flags); } |
c17bb4951
|
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 |
#ifdef CONFIG_FAIL_MAKE_REQUEST static DECLARE_FAULT_ATTR(fail_make_request); static int __init setup_fail_make_request(char *str) { return setup_fault_attr(&fail_make_request, str); } __setup("fail_make_request=", setup_fail_make_request); static int should_fail_request(struct bio *bio) { |
eddb2e26b
|
1291 1292 1293 |
struct hd_struct *part = bio->bi_bdev->bd_part; if (part_to_disk(part)->part0.make_it_fail || part->make_it_fail) |
c17bb4951
|
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 |
return should_fail(&fail_make_request, bio->bi_size); return 0; } static int __init fail_make_request_debugfs(void) { return init_fault_attr_dentries(&fail_make_request, "fail_make_request"); } late_initcall(fail_make_request_debugfs); #else /* CONFIG_FAIL_MAKE_REQUEST */ static inline int should_fail_request(struct bio *bio) { return 0; } #endif /* CONFIG_FAIL_MAKE_REQUEST */ |
c07e2b412
|
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 |
/* * Check whether this bio extends beyond the end of the device. */ static inline int bio_check_eod(struct bio *bio, unsigned int nr_sectors) { sector_t maxsector; if (!nr_sectors) return 0; /* Test device or partition size, when known. */ maxsector = bio->bi_bdev->bd_inode->i_size >> 9; if (maxsector) { sector_t sector = bio->bi_sector; if (maxsector < nr_sectors || maxsector - nr_sectors < sector) { /* * This may well happen - the kernel calls bread() * without checking the size of the device, e.g., when * mounting a device. */ handle_bad_sector(bio); return 1; } } return 0; } |
1da177e4c
|
1343 |
/** |
710027a48
|
1344 |
* generic_make_request - hand a buffer to its device driver for I/O |
1da177e4c
|
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 |
* @bio: The bio describing the location in memory and on the device. * * generic_make_request() is used to make I/O requests of block * devices. It is passed a &struct bio, which describes the I/O that needs * to be done. * * generic_make_request() does not return any status. The * success/failure status of the request, along with notification of * completion, is delivered asynchronously through the bio->bi_end_io * function described (one day) else where. * * The caller of generic_make_request must make sure that bi_io_vec * are set to describe the memory buffer, and that bi_dev and bi_sector are * set to describe the device address, and the * bi_end_io and optionally bi_private are set to describe how * completion notification should be signaled. * * generic_make_request and the drivers it calls may use bi_next if this * bio happens to be merged with someone else, and may change bi_dev and * bi_sector for remaps as it sees fit. So the values of these fields * should NOT be depended on after the call to generic_make_request. */ |
d89d87965
|
1367 |
static inline void __generic_make_request(struct bio *bio) |
1da177e4c
|
1368 |
{ |
165125e1e
|
1369 |
struct request_queue *q; |
5ddfe9691
|
1370 |
sector_t old_sector; |
1da177e4c
|
1371 |
int ret, nr_sectors = bio_sectors(bio); |
2056a782f
|
1372 |
dev_t old_dev; |
51fd77bd9
|
1373 |
int err = -EIO; |
1da177e4c
|
1374 1375 |
might_sleep(); |
1da177e4c
|
1376 |
|
c07e2b412
|
1377 1378 |
if (bio_check_eod(bio, nr_sectors)) goto end_io; |
1da177e4c
|
1379 1380 1381 1382 1383 1384 1385 1386 1387 |
/* * Resolve the mapping until finished. (drivers are * still free to implement/resolve their own stacking * by explicitly returning 0) * * NOTE: we don't repeat the blk_size check for each new device. * Stacking drivers are expected to know what they are doing. */ |
5ddfe9691
|
1388 |
old_sector = -1; |
2056a782f
|
1389 |
old_dev = 0; |
1da177e4c
|
1390 1391 1392 1393 |
do { char b[BDEVNAME_SIZE]; q = bdev_get_queue(bio->bi_bdev); |
a7384677b
|
1394 |
if (unlikely(!q)) { |
1da177e4c
|
1395 1396 1397 1398 1399 1400 |
printk(KERN_ERR "generic_make_request: Trying to access " "nonexistent block-device %s (%Lu) ", bdevname(bio->bi_bdev, b), (long long) bio->bi_sector); |
a7384677b
|
1401 |
goto end_io; |
1da177e4c
|
1402 |
} |
67efc9258
|
1403 1404 |
if (unlikely(!bio_rw_flagged(bio, BIO_RW_DISCARD) && nr_sectors > queue_max_hw_sectors(q))) { |
6728cb0e6
|
1405 1406 |
printk(KERN_ERR "bio too big device %s (%u > %u) ", |
ae03bf639
|
1407 1408 1409 |
bdevname(bio->bi_bdev, b), bio_sectors(bio), queue_max_hw_sectors(q)); |
1da177e4c
|
1410 1411 |
goto end_io; } |
fde6ad224
|
1412 |
if (unlikely(test_bit(QUEUE_FLAG_DEAD, &q->queue_flags))) |
1da177e4c
|
1413 |
goto end_io; |
c17bb4951
|
1414 1415 |
if (should_fail_request(bio)) goto end_io; |
1da177e4c
|
1416 1417 1418 1419 1420 |
/* * If this device has partitions, remap block n * of partition p to block n+start(p) of the disk. */ blk_partition_remap(bio); |
7ba1ba12e
|
1421 1422 |
if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) goto end_io; |
5ddfe9691
|
1423 |
if (old_sector != -1) |
22a7c31a9
|
1424 |
trace_block_remap(q, bio, old_dev, old_sector); |
2056a782f
|
1425 |
|
5ddfe9691
|
1426 |
old_sector = bio->bi_sector; |
2056a782f
|
1427 |
old_dev = bio->bi_bdev->bd_dev; |
c07e2b412
|
1428 1429 |
if (bio_check_eod(bio, nr_sectors)) goto end_io; |
a7384677b
|
1430 |
|
1f98a13f6
|
1431 |
if (bio_rw_flagged(bio, BIO_RW_DISCARD) && |
c15227de1
|
1432 |
!blk_queue_discard(q)) { |
51fd77bd9
|
1433 1434 1435 |
err = -EOPNOTSUPP; goto end_io; } |
5ddfe9691
|
1436 |
|
01edede41
|
1437 |
trace_block_bio_queue(q, bio); |
1da177e4c
|
1438 1439 |
ret = q->make_request_fn(q, bio); } while (ret); |
a7384677b
|
1440 1441 1442 1443 1444 |
return; end_io: bio_endio(bio, err); |
1da177e4c
|
1445 |
} |
d89d87965
|
1446 1447 1448 |
/* * We only want one ->make_request_fn to be active at a time, * else stack usage with stacked devices could be a problem. |
bddd87c7e
|
1449 |
* So use current->bio_list to keep a list of requests |
d89d87965
|
1450 |
* submited by a make_request_fn function. |
bddd87c7e
|
1451 |
* current->bio_list is also used as a flag to say if |
d89d87965
|
1452 1453 1454 1455 1456 1457 1458 |
* generic_make_request is currently active in this task or not. * If it is NULL, then no make_request is active. If it is non-NULL, * then a make_request is active, and new requests should be added * at the tail */ void generic_make_request(struct bio *bio) { |
bddd87c7e
|
1459 1460 1461 |
struct bio_list bio_list_on_stack; if (current->bio_list) { |
d89d87965
|
1462 |
/* make_request is active */ |
bddd87c7e
|
1463 |
bio_list_add(current->bio_list, bio); |
d89d87965
|
1464 1465 1466 1467 1468 1469 1470 |
return; } /* following loop may be a bit non-obvious, and so deserves some * explanation. * Before entering the loop, bio->bi_next is NULL (as all callers * ensure that) so we have a list with a single bio. * We pretend that we have just taken it off a longer list, so |
bddd87c7e
|
1471 1472 |
* we assign bio_list to a pointer to the bio_list_on_stack, * thus initialising the bio_list of new bios to be |
d89d87965
|
1473 1474 1475 1476 |
* added. __generic_make_request may indeed add some more bios * through a recursive call to generic_make_request. If it * did, we find a non-NULL value in bio_list and re-enter the loop * from the top. In this case we really did just take the bio |
bddd87c7e
|
1477 1478 |
* of the top of the list (no pretending) and so remove it from * bio_list, and call into __generic_make_request again. |
d89d87965
|
1479 1480 1481 1482 1483 1484 |
* * The loop was structured like this to make only one call to * __generic_make_request (which is important as it is large and * inlined) and to keep the structure simple. */ BUG_ON(bio->bi_next); |
bddd87c7e
|
1485 1486 |
bio_list_init(&bio_list_on_stack); current->bio_list = &bio_list_on_stack; |
d89d87965
|
1487 |
do { |
d89d87965
|
1488 |
__generic_make_request(bio); |
bddd87c7e
|
1489 |
bio = bio_list_pop(current->bio_list); |
d89d87965
|
1490 |
} while (bio); |
bddd87c7e
|
1491 |
current->bio_list = NULL; /* deactivate */ |
d89d87965
|
1492 |
} |
1da177e4c
|
1493 1494 1495 |
EXPORT_SYMBOL(generic_make_request); /** |
710027a48
|
1496 |
* submit_bio - submit a bio to the block device layer for I/O |
1da177e4c
|
1497 1498 1499 1500 1501 |
* @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead) * @bio: The &struct bio which describes the I/O * * submit_bio() is very similar in purpose to generic_make_request(), and * uses that function to do most of the work. Both are fairly rough |
710027a48
|
1502 |
* interfaces; @bio must be presetup and ready for I/O. |
1da177e4c
|
1503 1504 1505 1506 1507 |
* */ void submit_bio(int rw, struct bio *bio) { int count = bio_sectors(bio); |
22e2c507c
|
1508 |
bio->bi_rw |= rw; |
1da177e4c
|
1509 |
|
bf2de6f5a
|
1510 1511 1512 1513 |
/* * If it's a regular read/write or a barrier with data attached, * go through the normal accounting stuff before submission. */ |
a9c701e59
|
1514 |
if (bio_has_data(bio)) { |
bf2de6f5a
|
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 |
if (rw & WRITE) { count_vm_events(PGPGOUT, count); } else { task_io_account_read(bio->bi_size); count_vm_events(PGPGIN, count); } if (unlikely(block_dump)) { char b[BDEVNAME_SIZE]; printk(KERN_DEBUG "%s(%d): %s block %Lu on %s ", |
ba25f9dcc
|
1526 |
current->comm, task_pid_nr(current), |
bf2de6f5a
|
1527 1528 |
(rw & WRITE) ? "WRITE" : "READ", (unsigned long long)bio->bi_sector, |
6728cb0e6
|
1529 |
bdevname(bio->bi_bdev, b)); |
bf2de6f5a
|
1530 |
} |
1da177e4c
|
1531 1532 1533 1534 |
} generic_make_request(bio); } |
1da177e4c
|
1535 |
EXPORT_SYMBOL(submit_bio); |
3bcddeac1
|
1536 |
/** |
82124d603
|
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 |
* blk_rq_check_limits - Helper function to check a request for the queue limit * @q: the queue * @rq: the request being checked * * Description: * @rq may have been made based on weaker limitations of upper-level queues * in request stacking drivers, and it may violate the limitation of @q. * Since the block layer and the underlying device driver trust @rq * after it is inserted to @q, it should be checked against @q before * the insertion using this generic function. * * This function should also be useful for request stacking drivers * in some cases below, so export this fuction. * Request stacking drivers like request-based dm may change the queue * limits while requests are in the queue (e.g. dm's table swapping). * Such request stacking drivers should check those requests agaist * the new queue limits again when they dispatch those requests, * although such checkings are also done against the old queue limits * when submitting requests. */ int blk_rq_check_limits(struct request_queue *q, struct request *rq) { |
ae03bf639
|
1559 1560 |
if (blk_rq_sectors(rq) > queue_max_sectors(q) || blk_rq_bytes(rq) > queue_max_hw_sectors(q) << 9) { |
82124d603
|
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 |
printk(KERN_ERR "%s: over max size limit. ", __func__); return -EIO; } /* * queue's settings related to segment counting like q->bounce_pfn * may differ from that of other stacking queues. * Recalculate it to check the request correctly on this queue's * limitation. */ blk_recalc_rq_segments(rq); |
8a78362c4
|
1573 |
if (rq->nr_phys_segments > queue_max_segments(q)) { |
82124d603
|
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 |
printk(KERN_ERR "%s: over max segments limit. ", __func__); return -EIO; } return 0; } EXPORT_SYMBOL_GPL(blk_rq_check_limits); /** * blk_insert_cloned_request - Helper for stacking drivers to submit a request * @q: the queue to submit the request * @rq: the request being queued */ int blk_insert_cloned_request(struct request_queue *q, struct request *rq) { unsigned long flags; if (blk_rq_check_limits(q, rq)) return -EIO; #ifdef CONFIG_FAIL_MAKE_REQUEST if (rq->rq_disk && rq->rq_disk->part0.make_it_fail && should_fail(&fail_make_request, blk_rq_bytes(rq))) return -EIO; #endif spin_lock_irqsave(q->queue_lock, flags); /* * Submitting request must be dequeued before calling this function * because it will be linked to another request_queue */ BUG_ON(blk_queued_rq(rq)); drive_stat_acct(rq, 1); __elv_add_request(q, rq, ELEVATOR_INSERT_BACK, 0); spin_unlock_irqrestore(q->queue_lock, flags); return 0; } EXPORT_SYMBOL_GPL(blk_insert_cloned_request); |
80a761fd3
|
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 |
/** * blk_rq_err_bytes - determine number of bytes till the next failure boundary * @rq: request to examine * * Description: * A request could be merge of IOs which require different failure * handling. This function determines the number of bytes which * can be failed from the beginning of the request without * crossing into area which need to be retried further. * * Return: * The number of bytes to fail. * * Context: * queue_lock must be held. */ unsigned int blk_rq_err_bytes(const struct request *rq) { unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK; unsigned int bytes = 0; struct bio *bio; if (!(rq->cmd_flags & REQ_MIXED_MERGE)) return blk_rq_bytes(rq); /* * Currently the only 'mixing' which can happen is between * different fastfail types. We can safely fail portions * which have all the failfast bits that the first one has - * the ones which are at least as eager to fail as the first * one. */ for (bio = rq->bio; bio; bio = bio->bi_next) { if ((bio->bi_rw & ff) != ff) break; bytes += bio->bi_size; } /* this could lead to infinite loop */ BUG_ON(blk_rq_bytes(rq) && !bytes); return bytes; } EXPORT_SYMBOL_GPL(blk_rq_err_bytes); |
bc58ba946
|
1660 1661 |
static void blk_account_io_completion(struct request *req, unsigned int bytes) { |
c2553b584
|
1662 |
if (blk_do_io_stat(req)) { |
bc58ba946
|
1663 1664 1665 1666 1667 |
const int rw = rq_data_dir(req); struct hd_struct *part; int cpu; cpu = part_stat_lock(); |
83096ebf1
|
1668 |
part = disk_map_sector_rcu(req->rq_disk, blk_rq_pos(req)); |
bc58ba946
|
1669 1670 1671 1672 1673 1674 1675 |
part_stat_add(cpu, part, sectors[rw], bytes >> 9); part_stat_unlock(); } } static void blk_account_io_done(struct request *req) { |
bc58ba946
|
1676 1677 1678 1679 1680 |
/* * Account IO completion. bar_rq isn't accounted as a normal * IO on queueing nor completion. Accounting the containing * request is enough. */ |
c2553b584
|
1681 |
if (blk_do_io_stat(req) && req != &req->q->bar_rq) { |
bc58ba946
|
1682 1683 1684 1685 1686 1687 |
unsigned long duration = jiffies - req->start_time; const int rw = rq_data_dir(req); struct hd_struct *part; int cpu; cpu = part_stat_lock(); |
83096ebf1
|
1688 |
part = disk_map_sector_rcu(req->rq_disk, blk_rq_pos(req)); |
bc58ba946
|
1689 1690 1691 1692 |
part_stat_inc(cpu, part, ios[rw]); part_stat_add(cpu, part, ticks[rw], duration); part_round_stats(cpu, part); |
316d315bf
|
1693 |
part_dec_in_flight(part, rw); |
bc58ba946
|
1694 1695 1696 1697 |
part_stat_unlock(); } } |
53a08807c
|
1698 |
/** |
9934c8c04
|
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 |
* blk_peek_request - peek at the top of a request queue * @q: request queue to peek at * * Description: * Return the request at the top of @q. The returned request * should be started using blk_start_request() before LLD starts * processing it. * * Return: * Pointer to the request at the top of @q if available. Null * otherwise. * * Context: * queue_lock must be held. */ struct request *blk_peek_request(struct request_queue *q) |
158dbda00
|
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 |
{ struct request *rq; int ret; while ((rq = __elv_next_request(q)) != NULL) { if (!(rq->cmd_flags & REQ_STARTED)) { /* * This is the first time the device driver * sees this request (possibly after * requeueing). Notify IO scheduler. */ if (blk_sorted_rq(rq)) elv_activate_rq(q, rq); /* * just mark as started even if we don't start * it, a request that has been delayed should * not be passed by new incoming requests */ rq->cmd_flags |= REQ_STARTED; trace_block_rq_issue(q, rq); } if (!q->boundary_rq || q->boundary_rq == rq) { q->end_sector = rq_end_sector(rq); q->boundary_rq = NULL; } if (rq->cmd_flags & REQ_DONTPREP) break; |
2e46e8b27
|
1745 |
if (q->dma_drain_size && blk_rq_bytes(rq)) { |
158dbda00
|
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 |
/* * make sure space for the drain appears we * know we can do this because max_hw_segments * has been adjusted to be one fewer than the * device can handle */ rq->nr_phys_segments++; } if (!q->prep_rq_fn) break; ret = q->prep_rq_fn(q, rq); if (ret == BLKPREP_OK) { break; } else if (ret == BLKPREP_DEFER) { /* * the request may have been (partially) prepped. * we need to keep this request in the front to * avoid resource deadlock. REQ_STARTED will * prevent other fs requests from passing this one. */ |
2e46e8b27
|
1768 |
if (q->dma_drain_size && blk_rq_bytes(rq) && |
158dbda00
|
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 |
!(rq->cmd_flags & REQ_DONTPREP)) { /* * remove the space for the drain we added * so that we don't add it again */ --rq->nr_phys_segments; } rq = NULL; break; } else if (ret == BLKPREP_KILL) { rq->cmd_flags |= REQ_QUIET; |
c143dc903
|
1781 1782 1783 1784 1785 |
/* * Mark this request as started so we don't trigger * any debug logic in the end I/O path. */ blk_start_request(rq); |
40cbbb781
|
1786 |
__blk_end_request_all(rq, -EIO); |
158dbda00
|
1787 1788 1789 1790 1791 1792 1793 1794 1795 |
} else { printk(KERN_ERR "%s: bad return=%d ", __func__, ret); break; } } return rq; } |
9934c8c04
|
1796 |
EXPORT_SYMBOL(blk_peek_request); |
158dbda00
|
1797 |
|
9934c8c04
|
1798 |
void blk_dequeue_request(struct request *rq) |
158dbda00
|
1799 |
{ |
9934c8c04
|
1800 |
struct request_queue *q = rq->q; |
158dbda00
|
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 |
BUG_ON(list_empty(&rq->queuelist)); BUG_ON(ELV_ON_HASH(rq)); list_del_init(&rq->queuelist); /* * the time frame between a request being removed from the lists * and to it is freed is accounted as io that is in progress at * the driver side. */ |
9195291e5
|
1811 |
if (blk_account_rq(rq)) { |
0a7ae2ff0
|
1812 |
q->in_flight[rq_is_sync(rq)]++; |
9195291e5
|
1813 1814 |
set_io_start_time_ns(rq); } |
158dbda00
|
1815 |
} |
5efccd17c
|
1816 |
/** |
9934c8c04
|
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 |
* blk_start_request - start request processing on the driver * @req: request to dequeue * * Description: * Dequeue @req and start timeout timer on it. This hands off the * request to the driver. * * Block internal functions which don't want to start timer should * call blk_dequeue_request(). * * Context: * queue_lock must be held. */ void blk_start_request(struct request *req) { blk_dequeue_request(req); /* |
5f49f6317
|
1835 1836 |
* We are now handing the request to the hardware, initialize * resid_len to full count and add the timeout handler. |
9934c8c04
|
1837 |
*/ |
5f49f6317
|
1838 |
req->resid_len = blk_rq_bytes(req); |
dbb66c4be
|
1839 1840 |
if (unlikely(blk_bidi_rq(req))) req->next_rq->resid_len = blk_rq_bytes(req->next_rq); |
9934c8c04
|
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 |
blk_add_timer(req); } EXPORT_SYMBOL(blk_start_request); /** * blk_fetch_request - fetch a request from a request queue * @q: request queue to fetch a request from * * Description: * Return the request at the top of @q. The request is started on * return and LLD can start processing it immediately. * * Return: * Pointer to the request at the top of @q if available. Null * otherwise. * * Context: * queue_lock must be held. */ struct request *blk_fetch_request(struct request_queue *q) { struct request *rq; rq = blk_peek_request(q); if (rq) blk_start_request(rq); return rq; } EXPORT_SYMBOL(blk_fetch_request); /** |
2e60e0229
|
1872 |
* blk_update_request - Special helper function for request stacking drivers |
8ebf97560
|
1873 |
* @req: the request being processed |
710027a48
|
1874 |
* @error: %0 for success, < %0 for error |
8ebf97560
|
1875 |
* @nr_bytes: number of bytes to complete @req |
3bcddeac1
|
1876 1877 |
* * Description: |
8ebf97560
|
1878 1879 1880 |
* Ends I/O on a number of bytes attached to @req, but doesn't complete * the request structure even if @req doesn't have leftover. * If @req has leftover, sets it up for the next range of segments. |
2e60e0229
|
1881 1882 1883 1884 1885 1886 1887 |
* * This special helper function is only for request stacking drivers * (e.g. request-based dm) so that they can handle partial completion. * Actual device drivers should use blk_end_request instead. * * Passing the result of blk_rq_bytes() as @nr_bytes guarantees * %false return from this function. |
3bcddeac1
|
1888 1889 |
* * Return: |
2e60e0229
|
1890 1891 |
* %false - this request doesn't have any more data * %true - this request has more data |
3bcddeac1
|
1892 |
**/ |
2e60e0229
|
1893 |
bool blk_update_request(struct request *req, int error, unsigned int nr_bytes) |
1da177e4c
|
1894 |
{ |
5450d3e1d
|
1895 |
int total_bytes, bio_nbytes, next_idx = 0; |
1da177e4c
|
1896 |
struct bio *bio; |
2e60e0229
|
1897 1898 |
if (!req->bio) return false; |
5f3ea37c7
|
1899 |
trace_block_rq_complete(req->q, req); |
2056a782f
|
1900 |
|
1da177e4c
|
1901 |
/* |
6f41469c6
|
1902 1903 1904 1905 1906 1907 |
* For fs requests, rq is just carrier of independent bio's * and each partial completion should be handled separately. * Reset per-request error on each partial completion. * * TODO: tj: This is too subtle. It would be better to let * low level drivers do what they see fit. |
1da177e4c
|
1908 |
*/ |
6f41469c6
|
1909 |
if (blk_fs_request(req)) |
1da177e4c
|
1910 |
req->errors = 0; |
6728cb0e6
|
1911 1912 1913 |
if (error && (blk_fs_request(req) && !(req->cmd_flags & REQ_QUIET))) { printk(KERN_ERR "end_request: I/O error, dev %s, sector %llu ", |
1da177e4c
|
1914 |
req->rq_disk ? req->rq_disk->disk_name : "?", |
83096ebf1
|
1915 |
(unsigned long long)blk_rq_pos(req)); |
1da177e4c
|
1916 |
} |
bc58ba946
|
1917 |
blk_account_io_completion(req, nr_bytes); |
d72d904a5
|
1918 |
|
1da177e4c
|
1919 1920 1921 1922 1923 1924 1925 |
total_bytes = bio_nbytes = 0; while ((bio = req->bio) != NULL) { int nbytes; if (nr_bytes >= bio->bi_size) { req->bio = bio->bi_next; nbytes = bio->bi_size; |
5bb23a688
|
1926 |
req_bio_endio(req, bio, nbytes, error); |
1da177e4c
|
1927 1928 1929 1930 |
next_idx = 0; bio_nbytes = 0; } else { int idx = bio->bi_idx + next_idx; |
af498d7fa
|
1931 |
if (unlikely(idx >= bio->bi_vcnt)) { |
1da177e4c
|
1932 |
blk_dump_rq_flags(req, "__end_that"); |
6728cb0e6
|
1933 1934 |
printk(KERN_ERR "%s: bio idx %d >= vcnt %d ", |
af498d7fa
|
1935 |
__func__, idx, bio->bi_vcnt); |
1da177e4c
|
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 |
break; } nbytes = bio_iovec_idx(bio, idx)->bv_len; BIO_BUG_ON(nbytes > bio->bi_size); /* * not a complete bvec done */ if (unlikely(nbytes > nr_bytes)) { bio_nbytes += nr_bytes; total_bytes += nr_bytes; break; } /* * advance to the next vector */ next_idx++; bio_nbytes += nbytes; } total_bytes += nbytes; nr_bytes -= nbytes; |
6728cb0e6
|
1960 1961 |
bio = req->bio; if (bio) { |
1da177e4c
|
1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 |
/* * end more in this run, or just return 'not-done' */ if (unlikely(nr_bytes <= 0)) break; } } /* * completely done */ |
2e60e0229
|
1973 1974 1975 1976 1977 1978 |
if (!req->bio) { /* * Reset counters so that the request stacking driver * can find how many bytes remain in the request * later. */ |
a2dec7b36
|
1979 |
req->__data_len = 0; |
2e60e0229
|
1980 1981 |
return false; } |
1da177e4c
|
1982 1983 1984 1985 1986 |
/* * if the request wasn't completed, update state */ if (bio_nbytes) { |
5bb23a688
|
1987 |
req_bio_endio(req, bio, bio_nbytes, error); |
1da177e4c
|
1988 1989 1990 1991 |
bio->bi_idx += next_idx; bio_iovec(bio)->bv_offset += nr_bytes; bio_iovec(bio)->bv_len -= nr_bytes; } |
a2dec7b36
|
1992 |
req->__data_len -= total_bytes; |
2e46e8b27
|
1993 1994 1995 1996 |
req->buffer = bio_data(req->bio); /* update sector only for requests with clear definition of sector */ if (blk_fs_request(req) || blk_discard_rq(req)) |
a2dec7b36
|
1997 |
req->__sector += total_bytes >> 9; |
2e46e8b27
|
1998 |
|
80a761fd3
|
1999 2000 2001 2002 2003 |
/* mixed attributes always follow the first bio */ if (req->cmd_flags & REQ_MIXED_MERGE) { req->cmd_flags &= ~REQ_FAILFAST_MASK; req->cmd_flags |= req->bio->bi_rw & REQ_FAILFAST_MASK; } |
2e46e8b27
|
2004 2005 2006 2007 2008 2009 2010 |
/* * If total number of sectors is less than the first segment * size, something has gone terribly wrong. */ if (blk_rq_bytes(req) < blk_rq_cur_bytes(req)) { printk(KERN_ERR "blk: request botched "); |
a2dec7b36
|
2011 |
req->__data_len = blk_rq_cur_bytes(req); |
2e46e8b27
|
2012 2013 2014 |
} /* recalculate the number of segments */ |
1da177e4c
|
2015 |
blk_recalc_rq_segments(req); |
2e46e8b27
|
2016 |
|
2e60e0229
|
2017 |
return true; |
1da177e4c
|
2018 |
} |
2e60e0229
|
2019 |
EXPORT_SYMBOL_GPL(blk_update_request); |
1da177e4c
|
2020 |
|
2e60e0229
|
2021 2022 2023 |
static bool blk_update_bidi_request(struct request *rq, int error, unsigned int nr_bytes, unsigned int bidi_bytes) |
5efccd17c
|
2024 |
{ |
2e60e0229
|
2025 2026 |
if (blk_update_request(rq, error, nr_bytes)) return true; |
5efccd17c
|
2027 |
|
2e60e0229
|
2028 2029 2030 2031 |
/* Bidi request must be completed as a whole */ if (unlikely(blk_bidi_rq(rq)) && blk_update_request(rq->next_rq, error, bidi_bytes)) return true; |
5efccd17c
|
2032 |
|
2e60e0229
|
2033 2034 2035 |
add_disk_randomness(rq->rq_disk); return false; |
1da177e4c
|
2036 |
} |
1da177e4c
|
2037 2038 2039 |
/* * queue lock must be held */ |
2e60e0229
|
2040 |
static void blk_finish_request(struct request *req, int error) |
1da177e4c
|
2041 |
{ |
b8286239d
|
2042 2043 |
if (blk_rq_tagged(req)) blk_queue_end_tag(req->q, req); |
ba396a6c1
|
2044 |
BUG_ON(blk_queued_rq(req)); |
1da177e4c
|
2045 2046 |
if (unlikely(laptop_mode) && blk_fs_request(req)) |
31373d09d
|
2047 |
laptop_io_completion(&req->q->backing_dev_info); |
1da177e4c
|
2048 |
|
e78042e5b
|
2049 |
blk_delete_timer(req); |
bc58ba946
|
2050 |
blk_account_io_done(req); |
b8286239d
|
2051 |
|
1da177e4c
|
2052 |
if (req->end_io) |
8ffdc6550
|
2053 |
req->end_io(req, error); |
b8286239d
|
2054 2055 2056 |
else { if (blk_bidi_rq(req)) __blk_put_request(req->next_rq->q, req->next_rq); |
1da177e4c
|
2057 |
__blk_put_request(req->q, req); |
b8286239d
|
2058 |
} |
1da177e4c
|
2059 |
} |
3b11313a6
|
2060 |
/** |
2e60e0229
|
2061 2062 2063 2064 2065 |
* blk_end_bidi_request - Complete a bidi request * @rq: the request to complete * @error: %0 for success, < %0 for error * @nr_bytes: number of bytes to complete @rq * @bidi_bytes: number of bytes to complete @rq->next_rq |
a0cd12854
|
2066 2067 |
* * Description: |
e3a04fe34
|
2068 |
* Ends I/O on a number of bytes attached to @rq and @rq->next_rq. |
2e60e0229
|
2069 2070 2071 |
* Drivers that supports bidi can safely call this member for any * type of request, bidi or uni. In the later case @bidi_bytes is * just ignored. |
336cdb400
|
2072 2073 |
* * Return: |
2e60e0229
|
2074 2075 |
* %false - we are done with this request * %true - still buffers pending for this request |
a0cd12854
|
2076 |
**/ |
b1f744937
|
2077 |
static bool blk_end_bidi_request(struct request *rq, int error, |
32fab448e
|
2078 2079 |
unsigned int nr_bytes, unsigned int bidi_bytes) { |
336cdb400
|
2080 |
struct request_queue *q = rq->q; |
2e60e0229
|
2081 |
unsigned long flags; |
32fab448e
|
2082 |
|
2e60e0229
|
2083 2084 |
if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes)) return true; |
32fab448e
|
2085 |
|
336cdb400
|
2086 |
spin_lock_irqsave(q->queue_lock, flags); |
2e60e0229
|
2087 |
blk_finish_request(rq, error); |
336cdb400
|
2088 |
spin_unlock_irqrestore(q->queue_lock, flags); |
2e60e0229
|
2089 |
return false; |
32fab448e
|
2090 |
} |
336cdb400
|
2091 |
/** |
2e60e0229
|
2092 2093 |
* __blk_end_bidi_request - Complete a bidi request with queue lock held * @rq: the request to complete |
710027a48
|
2094 |
* @error: %0 for success, < %0 for error |
e3a04fe34
|
2095 2096 |
* @nr_bytes: number of bytes to complete @rq * @bidi_bytes: number of bytes to complete @rq->next_rq |
336cdb400
|
2097 2098 |
* * Description: |
2e60e0229
|
2099 2100 |
* Identical to blk_end_bidi_request() except that queue lock is * assumed to be locked on entry and remains so on return. |
336cdb400
|
2101 2102 |
* * Return: |
2e60e0229
|
2103 2104 |
* %false - we are done with this request * %true - still buffers pending for this request |
336cdb400
|
2105 |
**/ |
b1f744937
|
2106 2107 |
static bool __blk_end_bidi_request(struct request *rq, int error, unsigned int nr_bytes, unsigned int bidi_bytes) |
336cdb400
|
2108 |
{ |
2e60e0229
|
2109 2110 |
if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes)) return true; |
336cdb400
|
2111 |
|
2e60e0229
|
2112 |
blk_finish_request(rq, error); |
336cdb400
|
2113 |
|
2e60e0229
|
2114 |
return false; |
336cdb400
|
2115 |
} |
e19a3ab05
|
2116 2117 2118 2119 |
/** * blk_end_request - Helper function for drivers to complete the request. * @rq: the request being processed |
710027a48
|
2120 |
* @error: %0 for success, < %0 for error |
e19a3ab05
|
2121 2122 2123 2124 2125 2126 2127 |
* @nr_bytes: number of bytes to complete * * Description: * Ends I/O on a number of bytes attached to @rq. * If @rq has leftover, sets it up for the next range of segments. * * Return: |
b1f744937
|
2128 2129 |
* %false - we are done with this request * %true - still buffers pending for this request |
e19a3ab05
|
2130 |
**/ |
b1f744937
|
2131 |
bool blk_end_request(struct request *rq, int error, unsigned int nr_bytes) |
e19a3ab05
|
2132 |
{ |
b1f744937
|
2133 |
return blk_end_bidi_request(rq, error, nr_bytes, 0); |
e19a3ab05
|
2134 |
} |
56ad1740d
|
2135 |
EXPORT_SYMBOL(blk_end_request); |
336cdb400
|
2136 2137 |
/** |
b1f744937
|
2138 2139 |
* blk_end_request_all - Helper function for drives to finish the request. * @rq: the request to finish |
8ebf97560
|
2140 |
* @error: %0 for success, < %0 for error |
336cdb400
|
2141 2142 |
* * Description: |
b1f744937
|
2143 2144 2145 |
* Completely finish @rq. */ void blk_end_request_all(struct request *rq, int error) |
336cdb400
|
2146 |
{ |
b1f744937
|
2147 2148 |
bool pending; unsigned int bidi_bytes = 0; |
336cdb400
|
2149 |
|
b1f744937
|
2150 2151 |
if (unlikely(blk_bidi_rq(rq))) bidi_bytes = blk_rq_bytes(rq->next_rq); |
336cdb400
|
2152 |
|
b1f744937
|
2153 2154 2155 |
pending = blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes); BUG_ON(pending); } |
56ad1740d
|
2156 |
EXPORT_SYMBOL(blk_end_request_all); |
336cdb400
|
2157 |
|
b1f744937
|
2158 2159 2160 |
/** * blk_end_request_cur - Helper function to finish the current request chunk. * @rq: the request to finish the current chunk for |
8ebf97560
|
2161 |
* @error: %0 for success, < %0 for error |
b1f744937
|
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 |
* * Description: * Complete the current consecutively mapped chunk from @rq. * * Return: * %false - we are done with this request * %true - still buffers pending for this request */ bool blk_end_request_cur(struct request *rq, int error) { return blk_end_request(rq, error, blk_rq_cur_bytes(rq)); |
336cdb400
|
2173 |
} |
56ad1740d
|
2174 |
EXPORT_SYMBOL(blk_end_request_cur); |
336cdb400
|
2175 |
|
e19a3ab05
|
2176 |
/** |
80a761fd3
|
2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 |
* blk_end_request_err - Finish a request till the next failure boundary. * @rq: the request to finish till the next failure boundary for * @error: must be negative errno * * Description: * Complete @rq till the next failure boundary. * * Return: * %false - we are done with this request * %true - still buffers pending for this request */ bool blk_end_request_err(struct request *rq, int error) { WARN_ON(error >= 0); return blk_end_request(rq, error, blk_rq_err_bytes(rq)); } EXPORT_SYMBOL_GPL(blk_end_request_err); /** |
b1f744937
|
2196 2197 2198 2199 |
* __blk_end_request - Helper function for drivers to complete the request. * @rq: the request being processed * @error: %0 for success, < %0 for error * @nr_bytes: number of bytes to complete |
e3a04fe34
|
2200 2201 |
* * Description: |
b1f744937
|
2202 |
* Must be called with queue lock held unlike blk_end_request(). |
e3a04fe34
|
2203 2204 |
* * Return: |
b1f744937
|
2205 2206 |
* %false - we are done with this request * %true - still buffers pending for this request |
e3a04fe34
|
2207 |
**/ |
b1f744937
|
2208 |
bool __blk_end_request(struct request *rq, int error, unsigned int nr_bytes) |
e3a04fe34
|
2209 |
{ |
b1f744937
|
2210 |
return __blk_end_bidi_request(rq, error, nr_bytes, 0); |
e3a04fe34
|
2211 |
} |
56ad1740d
|
2212 |
EXPORT_SYMBOL(__blk_end_request); |
e3a04fe34
|
2213 2214 |
/** |
b1f744937
|
2215 2216 |
* __blk_end_request_all - Helper function for drives to finish the request. * @rq: the request to finish |
8ebf97560
|
2217 |
* @error: %0 for success, < %0 for error |
32fab448e
|
2218 2219 |
* * Description: |
b1f744937
|
2220 |
* Completely finish @rq. Must be called with queue lock held. |
32fab448e
|
2221 |
*/ |
b1f744937
|
2222 |
void __blk_end_request_all(struct request *rq, int error) |
32fab448e
|
2223 |
{ |
b1f744937
|
2224 2225 2226 2227 2228 2229 2230 2231 |
bool pending; unsigned int bidi_bytes = 0; if (unlikely(blk_bidi_rq(rq))) bidi_bytes = blk_rq_bytes(rq->next_rq); pending = __blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes); BUG_ON(pending); |
32fab448e
|
2232 |
} |
56ad1740d
|
2233 |
EXPORT_SYMBOL(__blk_end_request_all); |
32fab448e
|
2234 2235 |
/** |
b1f744937
|
2236 2237 |
* __blk_end_request_cur - Helper function to finish the current request chunk. * @rq: the request to finish the current chunk for |
8ebf97560
|
2238 |
* @error: %0 for success, < %0 for error |
e19a3ab05
|
2239 2240 |
* * Description: |
b1f744937
|
2241 2242 |
* Complete the current consecutively mapped chunk from @rq. Must * be called with queue lock held. |
e19a3ab05
|
2243 2244 |
* * Return: |
b1f744937
|
2245 2246 2247 2248 |
* %false - we are done with this request * %true - still buffers pending for this request */ bool __blk_end_request_cur(struct request *rq, int error) |
e19a3ab05
|
2249 |
{ |
b1f744937
|
2250 |
return __blk_end_request(rq, error, blk_rq_cur_bytes(rq)); |
e19a3ab05
|
2251 |
} |
56ad1740d
|
2252 |
EXPORT_SYMBOL(__blk_end_request_cur); |
e19a3ab05
|
2253 |
|
80a761fd3
|
2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 |
/** * __blk_end_request_err - Finish a request till the next failure boundary. * @rq: the request to finish till the next failure boundary for * @error: must be negative errno * * Description: * Complete @rq till the next failure boundary. Must be called * with queue lock held. * * Return: * %false - we are done with this request * %true - still buffers pending for this request */ bool __blk_end_request_err(struct request *rq, int error) { WARN_ON(error >= 0); return __blk_end_request(rq, error, blk_rq_err_bytes(rq)); } EXPORT_SYMBOL_GPL(__blk_end_request_err); |
86db1e297
|
2273 2274 |
void blk_rq_bio_prep(struct request_queue *q, struct request *rq, struct bio *bio) |
1da177e4c
|
2275 |
{ |
a82afdfcb
|
2276 2277 |
/* Bit 0 (R/W) is identical in rq->cmd_flags and bio->bi_rw */ rq->cmd_flags |= bio->bi_rw & REQ_RW; |
1da177e4c
|
2278 |
|
fb2dce862
|
2279 2280 |
if (bio_has_data(bio)) { rq->nr_phys_segments = bio_phys_segments(q, bio); |
fb2dce862
|
2281 2282 |
rq->buffer = bio_data(bio); } |
a2dec7b36
|
2283 |
rq->__data_len = bio->bi_size; |
1da177e4c
|
2284 |
rq->bio = rq->biotail = bio; |
1da177e4c
|
2285 |
|
66846572b
|
2286 2287 2288 |
if (bio->bi_bdev) rq->rq_disk = bio->bi_bdev->bd_disk; } |
1da177e4c
|
2289 |
|
2d4dc890b
|
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 |
#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE /** * rq_flush_dcache_pages - Helper function to flush all pages in a request * @rq: the request to be flushed * * Description: * Flush all pages in @rq. */ void rq_flush_dcache_pages(struct request *rq) { struct req_iterator iter; struct bio_vec *bvec; rq_for_each_segment(bvec, rq, iter) flush_dcache_page(bvec->bv_page); } EXPORT_SYMBOL_GPL(rq_flush_dcache_pages); #endif |
ef9e3facd
|
2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 |
/** * blk_lld_busy - Check if underlying low-level drivers of a device are busy * @q : the queue of the device being checked * * Description: * Check if underlying low-level drivers of a device are busy. * If the drivers want to export their busy state, they must set own * exporting function using blk_queue_lld_busy() first. * * Basically, this function is used only by request stacking drivers * to stop dispatching requests to underlying devices when underlying * devices are busy. This behavior helps more I/O merging on the queue * of the request stacking driver and prevents I/O throughput regression * on burst I/O load. * * Return: * 0 - Not busy (The request stacking driver should dispatch request) * 1 - Busy (The request stacking driver should stop dispatching request) */ int blk_lld_busy(struct request_queue *q) { if (q->lld_busy_fn) return q->lld_busy_fn(q); return 0; } EXPORT_SYMBOL_GPL(blk_lld_busy); |
b0fd271d5
|
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 |
/** * blk_rq_unprep_clone - Helper function to free all bios in a cloned request * @rq: the clone request to be cleaned up * * Description: * Free all bios in @rq for a cloned request. */ void blk_rq_unprep_clone(struct request *rq) { struct bio *bio; while ((bio = rq->bio) != NULL) { rq->bio = bio->bi_next; bio_put(bio); } } EXPORT_SYMBOL_GPL(blk_rq_unprep_clone); /* * Copy attributes of the original request to the clone request. * The actual data parts (e.g. ->cmd, ->buffer, ->sense) are not copied. */ static void __blk_rq_prep_clone(struct request *dst, struct request *src) { dst->cpu = src->cpu; dst->cmd_flags = (rq_data_dir(src) | REQ_NOMERGE); dst->cmd_type = src->cmd_type; dst->__sector = blk_rq_pos(src); dst->__data_len = blk_rq_bytes(src); dst->nr_phys_segments = src->nr_phys_segments; dst->ioprio = src->ioprio; dst->extra_len = src->extra_len; } /** * blk_rq_prep_clone - Helper function to setup clone request * @rq: the request to be setup * @rq_src: original request to be cloned * @bs: bio_set that bios for clone are allocated from * @gfp_mask: memory allocation mask for bio * @bio_ctr: setup function to be called for each clone bio. * Returns %0 for success, non %0 for failure. * @data: private data to be passed to @bio_ctr * * Description: * Clones bios in @rq_src to @rq, and copies attributes of @rq_src to @rq. * The actual data parts of @rq_src (e.g. ->cmd, ->buffer, ->sense) * are not copied, and copying such parts is the caller's responsibility. * Also, pages which the original bios are pointing to are not copied * and the cloned bios just point same pages. * So cloned bios must be completed before original bios, which means * the caller must complete @rq before @rq_src. */ int blk_rq_prep_clone(struct request *rq, struct request *rq_src, struct bio_set *bs, gfp_t gfp_mask, int (*bio_ctr)(struct bio *, struct bio *, void *), void *data) { struct bio *bio, *bio_src; if (!bs) bs = fs_bio_set; blk_rq_init(NULL, rq); __rq_for_each_bio(bio_src, rq_src) { bio = bio_alloc_bioset(gfp_mask, bio_src->bi_max_vecs, bs); if (!bio) goto free_and_out; __bio_clone(bio, bio_src); if (bio_integrity(bio_src) && |
7878cba9f
|
2409 |
bio_integrity_clone(bio, bio_src, gfp_mask, bs)) |
b0fd271d5
|
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 |
goto free_and_out; if (bio_ctr && bio_ctr(bio, bio_src, data)) goto free_and_out; if (rq->bio) { rq->biotail->bi_next = bio; rq->biotail = bio; } else rq->bio = rq->biotail = bio; } __blk_rq_prep_clone(rq, rq_src); return 0; free_and_out: if (bio) bio_free(bio, bs); blk_rq_unprep_clone(rq); return -ENOMEM; } EXPORT_SYMBOL_GPL(blk_rq_prep_clone); |
18887ad91
|
2434 |
int kblockd_schedule_work(struct request_queue *q, struct work_struct *work) |
1da177e4c
|
2435 2436 2437 |
{ return queue_work(kblockd_workqueue, work); } |
1da177e4c
|
2438 |
EXPORT_SYMBOL(kblockd_schedule_work); |
1da177e4c
|
2439 2440 |
int __init blk_dev_init(void) { |
9eb55b030
|
2441 2442 |
BUILD_BUG_ON(__REQ_NR_BITS > 8 * sizeof(((struct request *)0)->cmd_flags)); |
1da177e4c
|
2443 2444 2445 2446 2447 2448 |
kblockd_workqueue = create_workqueue("kblockd"); if (!kblockd_workqueue) panic("Failed to create kblockd "); request_cachep = kmem_cache_create("blkdev_requests", |
20c2df83d
|
2449 |
sizeof(struct request), 0, SLAB_PANIC, NULL); |
1da177e4c
|
2450 |
|
8324aa91d
|
2451 |
blk_requestq_cachep = kmem_cache_create("blkdev_queue", |
165125e1e
|
2452 |
sizeof(struct request_queue), 0, SLAB_PANIC, NULL); |
1da177e4c
|
2453 |
|
d38ecf935
|
2454 |
return 0; |
1da177e4c
|
2455 |
} |