Blame view
fs/direct-io.c
38.5 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 7 |
/* * fs/direct-io.c * * Copyright (C) 2002, Linus Torvalds. * * O_DIRECT * |
e1f8e8744 Remove Andrew Mor... |
8 |
* 04Jul2002 Andrew Morton |
1da177e4c Linux-2.6.12-rc2 |
9 10 11 |
* Initial version * 11Sep2002 janetinc@us.ibm.com * added readv/writev support. |
e1f8e8744 Remove Andrew Mor... |
12 |
* 29Oct2002 Andrew Morton |
1da177e4c Linux-2.6.12-rc2 |
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
* rewrote bio_add_page() support. * 30Oct2002 pbadari@us.ibm.com * added support for non-aligned IO. * 06Nov2002 pbadari@us.ibm.com * added asynchronous IO support. * 21Jul2003 nathans@sgi.com * added IO completion notifier. */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/types.h> #include <linux/fs.h> #include <linux/mm.h> #include <linux/slab.h> #include <linux/highmem.h> #include <linux/pagemap.h> |
98c4d57de [PATCH] io-accoun... |
30 |
#include <linux/task_io_accounting_ops.h> |
1da177e4c Linux-2.6.12-rc2 |
31 32 33 34 35 36 37 |
#include <linux/bio.h> #include <linux/wait.h> #include <linux/err.h> #include <linux/blkdev.h> #include <linux/buffer_head.h> #include <linux/rwsem.h> #include <linux/uio.h> |
60063497a atomic: use <linu... |
38 |
#include <linux/atomic.h> |
65dd2aa90 dio: optimize cac... |
39 |
#include <linux/prefetch.h> |
1da177e4c Linux-2.6.12-rc2 |
40 41 42 |
/* * How many user pages to map in one call to get_user_pages(). This determines |
cde1ecb32 direct-io: fix a ... |
43 |
* the size of a structure in the slab cache |
1da177e4c Linux-2.6.12-rc2 |
44 45 46 47 48 49 50 51 52 53 54 55 56 |
*/ #define DIO_PAGES 64 /* * This code generally works in units of "dio_blocks". A dio_block is * somewhere between the hard sector size and the filesystem block size. it * is determined on a per-invocation basis. When talking to the filesystem * we need to convert dio_blocks to fs_blocks by scaling the dio_block quantity * down by dio->blkfactor. Similarly, fs-blocksize quantities are converted * to bio_block quantities by shifting left by blkfactor. * * If blkfactor is zero then the user's request was aligned to the filesystem's * blocksize. |
1da177e4c Linux-2.6.12-rc2 |
57 |
*/ |
eb28be2b4 direct-io: separa... |
58 59 60 |
/* dio_state only used in the submission path */ struct dio_submit { |
1da177e4c Linux-2.6.12-rc2 |
61 |
struct bio *bio; /* bio under assembly */ |
1da177e4c Linux-2.6.12-rc2 |
62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
unsigned blkbits; /* doesn't change */ unsigned blkfactor; /* When we're using an alignment which is finer than the filesystem's soft blocksize, this specifies how much finer. blkfactor=2 means 1/4-block alignment. Does not change */ unsigned start_zero_done; /* flag: sub-blocksize zeroing has been performed at the start of a write */ int pages_in_io; /* approximate total IO pages */ size_t size; /* total request size (doesn't change)*/ sector_t block_in_file; /* Current offset into the underlying file in dio_block units. */ unsigned blocks_available; /* At block_in_file. changes */ |
0dc2bc49b direct-io: rearra... |
76 |
int reap_counter; /* rate limit reaping */ |
1da177e4c Linux-2.6.12-rc2 |
77 78 79 |
sector_t final_block_in_request;/* doesn't change */ unsigned first_block_in_page; /* doesn't change, Used only once */ int boundary; /* prev block is at a boundary */ |
1d8fa7a2b [PATCH] remove ->... |
80 |
get_block_t *get_block; /* block mapping function */ |
facd07b07 direct-io: add a ... |
81 |
dio_submit_t *submit_io; /* IO submition function */ |
eb28be2b4 direct-io: separa... |
82 |
|
facd07b07 direct-io: add a ... |
83 |
loff_t logical_offset_in_bio; /* current first logical block in bio */ |
1da177e4c Linux-2.6.12-rc2 |
84 85 86 |
sector_t final_block_in_bio; /* current final block in bio + 1 */ sector_t next_block_for_io; /* next block to be put under IO, in dio_blocks units */ |
1da177e4c Linux-2.6.12-rc2 |
87 88 89 90 91 92 93 94 95 96 |
/* * Deferred addition of a page to the dio. These variables are * private to dio_send_cur_page(), submit_page_section() and * dio_bio_add_page(). */ struct page *cur_page; /* The page */ unsigned cur_page_offset; /* Offset into it, in bytes */ unsigned cur_page_len; /* Nr of bytes at cur_page_offset */ sector_t cur_page_block; /* Where it starts */ |
facd07b07 direct-io: add a ... |
97 |
loff_t cur_page_fs_offset; /* Offset in file */ |
1da177e4c Linux-2.6.12-rc2 |
98 99 100 101 102 103 104 105 106 107 108 109 |
/* * Page fetching state. These variables belong to dio_refill_pages(). */ int curr_page; /* changes */ int total_pages; /* doesn't change */ unsigned long curr_user_address;/* changes */ /* * Page queue. These variables belong to dio_refill_pages() and * dio_get_page(). */ |
1da177e4c Linux-2.6.12-rc2 |
110 111 |
unsigned head; /* next page to process */ unsigned tail; /* last valid page + 1 */ |
eb28be2b4 direct-io: separa... |
112 113 114 115 116 |
}; /* dio_state communicated between submission path and end_io */ struct dio { int flags; /* doesn't change */ |
eb28be2b4 direct-io: separa... |
117 |
int rw; |
0dc2bc49b direct-io: rearra... |
118 |
struct inode *inode; |
eb28be2b4 direct-io: separa... |
119 120 |
loff_t i_size; /* i_size when submitted */ dio_iodone_t *end_io; /* IO completion function */ |
eb28be2b4 direct-io: separa... |
121 |
|
18772641d direct-io: separa... |
122 |
void *private; /* copy from map_bh.b_private */ |
eb28be2b4 direct-io: separa... |
123 124 125 |
/* BIO completion state */ spinlock_t bio_lock; /* protects BIO fields below */ |
0dc2bc49b direct-io: rearra... |
126 127 128 |
int page_errors; /* errno from get_user_pages() */ int is_async; /* is IO async ? */ int io_error; /* IO error in completion path */ |
eb28be2b4 direct-io: separa... |
129 130 131 132 133 134 |
unsigned long refcount; /* direct_io_worker() and bios */ struct bio *bio_list; /* singly linked via bi_private */ struct task_struct *waiter; /* waiting task (NULL if none) */ /* AIO related stuff */ struct kiocb *iocb; /* kiocb */ |
eb28be2b4 direct-io: separa... |
135 |
ssize_t result; /* IO result */ |
23aee091d dio: don't zero o... |
136 137 138 139 140 141 |
/* * pages[] (and any fields placed after it) are not zeroed out at * allocation time. Don't add new fields after pages[] unless you * wish that they not be zeroed. */ struct page *pages[DIO_PAGES]; /* page buffer */ |
6e8267f53 direct-io: use a ... |
142 143 144 |
} ____cacheline_aligned_in_smp; static struct kmem_cache *dio_cache __read_mostly; |
1da177e4c Linux-2.6.12-rc2 |
145 |
|
bd5fe6c5e fs: kill i_alloc_sem |
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 187 188 |
static void __inode_dio_wait(struct inode *inode) { wait_queue_head_t *wq = bit_waitqueue(&inode->i_state, __I_DIO_WAKEUP); DEFINE_WAIT_BIT(q, &inode->i_state, __I_DIO_WAKEUP); do { prepare_to_wait(wq, &q.wait, TASK_UNINTERRUPTIBLE); if (atomic_read(&inode->i_dio_count)) schedule(); } while (atomic_read(&inode->i_dio_count)); finish_wait(wq, &q.wait); } /** * inode_dio_wait - wait for outstanding DIO requests to finish * @inode: inode to wait for * * Waits for all pending direct I/O requests to finish so that we can * proceed with a truncate or equivalent operation. * * Must be called under a lock that serializes taking new references * to i_dio_count, usually by inode->i_mutex. */ void inode_dio_wait(struct inode *inode) { if (atomic_read(&inode->i_dio_count)) __inode_dio_wait(inode); } EXPORT_SYMBOL_GPL(inode_dio_wait); /* * inode_dio_done - signal finish of a direct I/O requests * @inode: inode the direct I/O happens on * * This is called once we've finished processing a direct I/O request, * and is used to wake up callers waiting for direct I/O to be quiesced. */ void inode_dio_done(struct inode *inode) { if (atomic_dec_and_test(&inode->i_dio_count)) wake_up_bit(&inode->i_state, __I_DIO_WAKEUP); } EXPORT_SYMBOL_GPL(inode_dio_done); |
1da177e4c Linux-2.6.12-rc2 |
189 190 191 |
/* * How many pages are in the queue? */ |
eb28be2b4 direct-io: separa... |
192 |
static inline unsigned dio_pages_present(struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
193 |
{ |
eb28be2b4 direct-io: separa... |
194 |
return sdio->tail - sdio->head; |
1da177e4c Linux-2.6.12-rc2 |
195 196 197 198 199 |
} /* * Go grab and pin some userspace pages. Typically we'll get 64 at a time. */ |
ba253fbf6 direct-io: inline... |
200 |
static inline int dio_refill_pages(struct dio *dio, struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
201 202 203 |
{ int ret; int nr_pages; |
eb28be2b4 direct-io: separa... |
204 |
nr_pages = min(sdio->total_pages - sdio->curr_page, DIO_PAGES); |
f5dd33c49 dio: use get_user... |
205 |
ret = get_user_pages_fast( |
eb28be2b4 direct-io: separa... |
206 |
sdio->curr_user_address, /* Where from? */ |
1da177e4c Linux-2.6.12-rc2 |
207 208 |
nr_pages, /* How many pages? */ dio->rw == READ, /* Write to memory? */ |
f5dd33c49 dio: use get_user... |
209 |
&dio->pages[0]); /* Put results here */ |
1da177e4c Linux-2.6.12-rc2 |
210 |
|
eb28be2b4 direct-io: separa... |
211 |
if (ret < 0 && sdio->blocks_available && (dio->rw & WRITE)) { |
557ed1fa2 remove ZERO_PAGE |
212 |
struct page *page = ZERO_PAGE(0); |
1da177e4c Linux-2.6.12-rc2 |
213 214 215 216 217 218 219 |
/* * A memory fault, but the filesystem has some outstanding * mapped blocks. We need to use those blocks up to avoid * leaking stale data in the file. */ if (dio->page_errors == 0) dio->page_errors = ret; |
b5810039a [PATCH] core remo... |
220 221 |
page_cache_get(page); dio->pages[0] = page; |
eb28be2b4 direct-io: separa... |
222 223 |
sdio->head = 0; sdio->tail = 1; |
1da177e4c Linux-2.6.12-rc2 |
224 225 226 227 228 |
ret = 0; goto out; } if (ret >= 0) { |
eb28be2b4 direct-io: separa... |
229 230 231 232 |
sdio->curr_user_address += ret * PAGE_SIZE; sdio->curr_page += ret; sdio->head = 0; sdio->tail = ret; |
1da177e4c Linux-2.6.12-rc2 |
233 234 235 236 237 238 239 240 241 242 243 244 |
ret = 0; } out: return ret; } /* * Get another userspace page. Returns an ERR_PTR on error. Pages are * buffered inside the dio so that we can call get_user_pages() against a * decent number of pages, less frequently. To provide nicer use of the * L1 cache. */ |
ba253fbf6 direct-io: inline... |
245 246 |
static inline struct page *dio_get_page(struct dio *dio, struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
247 |
{ |
eb28be2b4 direct-io: separa... |
248 |
if (dio_pages_present(sdio) == 0) { |
1da177e4c Linux-2.6.12-rc2 |
249 |
int ret; |
eb28be2b4 direct-io: separa... |
250 |
ret = dio_refill_pages(dio, sdio); |
1da177e4c Linux-2.6.12-rc2 |
251 252 |
if (ret) return ERR_PTR(ret); |
eb28be2b4 direct-io: separa... |
253 |
BUG_ON(dio_pages_present(sdio) == 0); |
1da177e4c Linux-2.6.12-rc2 |
254 |
} |
eb28be2b4 direct-io: separa... |
255 |
return dio->pages[sdio->head++]; |
1da177e4c Linux-2.6.12-rc2 |
256 |
} |
6d544bb4d [PATCH] dio: cent... |
257 258 259 260 261 262 263 264 265 266 267 268 |
/** * dio_complete() - called when all DIO BIO I/O has been completed * @offset: the byte offset in the file of the completed operation * * This releases locks as dictated by the locking type, lets interested parties * know that a DIO operation has completed, and calculates the resulting return * code for the operation. * * It lets the filesystem know if it registered an interest earlier via * get_block. Pass the private field of the map buffer_head so that * filesystems can use it to hold additional state between get_block calls and * dio_complete. |
1da177e4c Linux-2.6.12-rc2 |
269 |
*/ |
cd1c584f3 fs/direct-io.c: f... |
270 |
static ssize_t dio_complete(struct dio *dio, loff_t offset, ssize_t ret, bool is_async) |
1da177e4c Linux-2.6.12-rc2 |
271 |
{ |
6d544bb4d [PATCH] dio: cent... |
272 |
ssize_t transferred = 0; |
8459d86af [PATCH] dio: only... |
273 274 275 276 277 278 279 280 |
/* * AIO submission can race with bio completion to get here while * expecting to have the last io completed by bio completion. * In that case -EIOCBQUEUED is in fact not an error we want * to preserve through this call. */ if (ret == -EIOCBQUEUED) ret = 0; |
6d544bb4d [PATCH] dio: cent... |
281 282 283 284 285 286 287 |
if (dio->result) { transferred = dio->result; /* Check for short read case */ if ((dio->rw == READ) && ((offset + transferred) > dio->i_size)) transferred = dio->i_size - offset; } |
6d544bb4d [PATCH] dio: cent... |
288 289 290 291 292 293 |
if (ret == 0) ret = dio->page_errors; if (ret == 0) ret = dio->io_error; if (ret == 0) ret = transferred; |
40e2e9731 direct-io: move a... |
294 295 |
if (dio->end_io && dio->result) { dio->end_io(dio->iocb, offset, transferred, |
18772641d direct-io: separa... |
296 |
dio->private, ret, is_async); |
72c5052dd fs: move inode_di... |
297 298 299 300 |
} else { if (is_async) aio_complete(dio->iocb, ret, 0); inode_dio_done(dio->inode); |
40e2e9731 direct-io: move a... |
301 |
} |
6d544bb4d [PATCH] dio: cent... |
302 |
return ret; |
1da177e4c Linux-2.6.12-rc2 |
303 |
} |
1da177e4c Linux-2.6.12-rc2 |
304 305 306 307 |
static int dio_bio_complete(struct dio *dio, struct bio *bio); /* * Asynchronous IO callback. */ |
6712ecf8f Drop 'size' argum... |
308 |
static void dio_bio_end_aio(struct bio *bio, int error) |
1da177e4c Linux-2.6.12-rc2 |
309 310 |
{ struct dio *dio = bio->bi_private; |
5eb6c7a2a [PATCH] dio: lock... |
311 312 |
unsigned long remaining; unsigned long flags; |
1da177e4c Linux-2.6.12-rc2 |
313 |
|
1da177e4c Linux-2.6.12-rc2 |
314 315 |
/* cleanup the bio */ dio_bio_complete(dio, bio); |
0273201e6 [PATCH] dio: form... |
316 |
|
5eb6c7a2a [PATCH] dio: lock... |
317 318 319 |
spin_lock_irqsave(&dio->bio_lock, flags); remaining = --dio->refcount; if (remaining == 1 && dio->waiter) |
20258b2b3 [PATCH] dio: remo... |
320 |
wake_up_process(dio->waiter); |
5eb6c7a2a [PATCH] dio: lock... |
321 |
spin_unlock_irqrestore(&dio->bio_lock, flags); |
20258b2b3 [PATCH] dio: remo... |
322 |
|
8459d86af [PATCH] dio: only... |
323 |
if (remaining == 0) { |
40e2e9731 direct-io: move a... |
324 |
dio_complete(dio, dio->iocb->ki_pos, 0, true); |
6e8267f53 direct-io: use a ... |
325 |
kmem_cache_free(dio_cache, dio); |
8459d86af [PATCH] dio: only... |
326 |
} |
1da177e4c Linux-2.6.12-rc2 |
327 328 329 330 331 332 333 334 335 |
} /* * The BIO completion handler simply queues the BIO up for the process-context * handler. * * During I/O bi_private points at the dio. After I/O, bi_private is used to * implement a singly-linked list of completed BIOs, at dio->bio_list. */ |
6712ecf8f Drop 'size' argum... |
336 |
static void dio_bio_end_io(struct bio *bio, int error) |
1da177e4c Linux-2.6.12-rc2 |
337 338 339 |
{ struct dio *dio = bio->bi_private; unsigned long flags; |
1da177e4c Linux-2.6.12-rc2 |
340 341 342 |
spin_lock_irqsave(&dio->bio_lock, flags); bio->bi_private = dio->bio_list; dio->bio_list = bio; |
5eb6c7a2a [PATCH] dio: lock... |
343 |
if (--dio->refcount == 1 && dio->waiter) |
1da177e4c Linux-2.6.12-rc2 |
344 345 |
wake_up_process(dio->waiter); spin_unlock_irqrestore(&dio->bio_lock, flags); |
1da177e4c Linux-2.6.12-rc2 |
346 |
} |
facd07b07 direct-io: add a ... |
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 |
/** * dio_end_io - handle the end io action for the given bio * @bio: The direct io bio thats being completed * @error: Error if there was one * * This is meant to be called by any filesystem that uses their own dio_submit_t * so that the DIO specific endio actions are dealt with after the filesystem * has done it's completion work. */ void dio_end_io(struct bio *bio, int error) { struct dio *dio = bio->bi_private; if (dio->is_async) dio_bio_end_aio(bio, error); else dio_bio_end_io(bio, error); } EXPORT_SYMBOL_GPL(dio_end_io); |
ba253fbf6 direct-io: inline... |
366 |
static inline void |
eb28be2b4 direct-io: separa... |
367 368 369 |
dio_bio_alloc(struct dio *dio, struct dio_submit *sdio, struct block_device *bdev, sector_t first_sector, int nr_vecs) |
1da177e4c Linux-2.6.12-rc2 |
370 371 |
{ struct bio *bio; |
20d9600cb fs/direct-io.c: d... |
372 373 374 375 |
/* * bio_alloc() is guaranteed to return a bio when called with * __GFP_WAIT and we request a valid number of vectors. */ |
1da177e4c Linux-2.6.12-rc2 |
376 |
bio = bio_alloc(GFP_KERNEL, nr_vecs); |
1da177e4c Linux-2.6.12-rc2 |
377 378 379 380 381 382 383 |
bio->bi_bdev = bdev; bio->bi_sector = first_sector; if (dio->is_async) bio->bi_end_io = dio_bio_end_aio; else bio->bi_end_io = dio_bio_end_io; |
eb28be2b4 direct-io: separa... |
384 385 |
sdio->bio = bio; sdio->logical_offset_in_bio = sdio->cur_page_fs_offset; |
1da177e4c Linux-2.6.12-rc2 |
386 387 388 389 390 391 |
} /* * In the AIO read case we speculatively dirty the pages before starting IO. * During IO completion, any of these pages which happen to have been written * back will be redirtied by bio_check_pages_dirty(). |
0273201e6 [PATCH] dio: form... |
392 393 |
* * bios hold a dio reference between submit_bio and ->end_io. |
1da177e4c Linux-2.6.12-rc2 |
394 |
*/ |
ba253fbf6 direct-io: inline... |
395 |
static inline void dio_bio_submit(struct dio *dio, struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
396 |
{ |
eb28be2b4 direct-io: separa... |
397 |
struct bio *bio = sdio->bio; |
5eb6c7a2a [PATCH] dio: lock... |
398 |
unsigned long flags; |
1da177e4c Linux-2.6.12-rc2 |
399 400 |
bio->bi_private = dio; |
5eb6c7a2a [PATCH] dio: lock... |
401 402 403 404 |
spin_lock_irqsave(&dio->bio_lock, flags); dio->refcount++; spin_unlock_irqrestore(&dio->bio_lock, flags); |
1da177e4c Linux-2.6.12-rc2 |
405 406 |
if (dio->is_async && dio->rw == READ) bio_set_pages_dirty(bio); |
5eb6c7a2a [PATCH] dio: lock... |
407 |
|
eb28be2b4 direct-io: separa... |
408 409 410 |
if (sdio->submit_io) sdio->submit_io(dio->rw, bio, dio->inode, sdio->logical_offset_in_bio); |
facd07b07 direct-io: add a ... |
411 412 |
else submit_bio(dio->rw, bio); |
1da177e4c Linux-2.6.12-rc2 |
413 |
|
eb28be2b4 direct-io: separa... |
414 415 416 |
sdio->bio = NULL; sdio->boundary = 0; sdio->logical_offset_in_bio = 0; |
1da177e4c Linux-2.6.12-rc2 |
417 418 419 420 421 |
} /* * Release any resources in case of a failure */ |
ba253fbf6 direct-io: inline... |
422 |
static inline void dio_cleanup(struct dio *dio, struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
423 |
{ |
eb28be2b4 direct-io: separa... |
424 425 |
while (dio_pages_present(sdio)) page_cache_release(dio_get_page(dio, sdio)); |
1da177e4c Linux-2.6.12-rc2 |
426 427 428 |
} /* |
0273201e6 [PATCH] dio: form... |
429 430 431 432 |
* Wait for the next BIO to complete. Remove it and return it. NULL is * returned once all BIOs have been completed. This must only be called once * all bios have been issued so that dio->refcount can only decrease. This * requires that that the caller hold a reference on the dio. |
1da177e4c Linux-2.6.12-rc2 |
433 434 435 436 |
*/ static struct bio *dio_await_one(struct dio *dio) { unsigned long flags; |
0273201e6 [PATCH] dio: form... |
437 |
struct bio *bio = NULL; |
1da177e4c Linux-2.6.12-rc2 |
438 439 |
spin_lock_irqsave(&dio->bio_lock, flags); |
5eb6c7a2a [PATCH] dio: lock... |
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 |
/* * Wait as long as the list is empty and there are bios in flight. bio * completion drops the count, maybe adds to the list, and wakes while * holding the bio_lock so we don't need set_current_state()'s barrier * and can call it after testing our condition. */ while (dio->refcount > 1 && dio->bio_list == NULL) { __set_current_state(TASK_UNINTERRUPTIBLE); dio->waiter = current; spin_unlock_irqrestore(&dio->bio_lock, flags); io_schedule(); /* wake up sets us TASK_RUNNING */ spin_lock_irqsave(&dio->bio_lock, flags); dio->waiter = NULL; |
1da177e4c Linux-2.6.12-rc2 |
455 |
} |
0273201e6 [PATCH] dio: form... |
456 457 458 459 |
if (dio->bio_list) { bio = dio->bio_list; dio->bio_list = bio->bi_private; } |
1da177e4c Linux-2.6.12-rc2 |
460 461 462 463 464 465 466 467 468 469 470 471 472 473 |
spin_unlock_irqrestore(&dio->bio_lock, flags); return bio; } /* * Process one completed BIO. No locks are held. */ static int dio_bio_complete(struct dio *dio, struct bio *bio) { const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags); struct bio_vec *bvec = bio->bi_io_vec; int page_no; if (!uptodate) |
174e27c60 [PATCH] direct-io... |
474 |
dio->io_error = -EIO; |
1da177e4c Linux-2.6.12-rc2 |
475 476 477 478 479 480 481 482 483 484 485 486 487 |
if (dio->is_async && dio->rw == READ) { bio_check_pages_dirty(bio); /* transfers ownership */ } else { for (page_no = 0; page_no < bio->bi_vcnt; page_no++) { struct page *page = bvec[page_no].bv_page; if (dio->rw == READ && !PageCompound(page)) set_page_dirty_lock(page); page_cache_release(page); } bio_put(bio); } |
1da177e4c Linux-2.6.12-rc2 |
488 489 490 491 |
return uptodate ? 0 : -EIO; } /* |
0273201e6 [PATCH] dio: form... |
492 493 494 |
* Wait on and process all in-flight BIOs. This must only be called once * all bios have been issued so that the refcount can only decrease. * This just waits for all bios to make it through dio_bio_complete. IO |
beb7dd86a Fix misspellings ... |
495 |
* errors are propagated through dio->io_error and should be propagated via |
0273201e6 [PATCH] dio: form... |
496 |
* dio_complete(). |
1da177e4c Linux-2.6.12-rc2 |
497 |
*/ |
6d544bb4d [PATCH] dio: cent... |
498 |
static void dio_await_completion(struct dio *dio) |
1da177e4c Linux-2.6.12-rc2 |
499 |
{ |
0273201e6 [PATCH] dio: form... |
500 501 502 503 504 505 |
struct bio *bio; do { bio = dio_await_one(dio); if (bio) dio_bio_complete(dio, bio); } while (bio); |
1da177e4c Linux-2.6.12-rc2 |
506 507 508 509 510 511 512 513 514 |
} /* * A really large O_DIRECT read or write can generate a lot of BIOs. So * to keep the memory consumption sane we periodically reap any completed BIOs * during the BIO generation phase. * * This also helps to limit the peak amount of pinned userspace memory. */ |
ba253fbf6 direct-io: inline... |
515 |
static inline int dio_bio_reap(struct dio *dio, struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
516 517 |
{ int ret = 0; |
eb28be2b4 direct-io: separa... |
518 |
if (sdio->reap_counter++ >= 64) { |
1da177e4c Linux-2.6.12-rc2 |
519 520 521 522 523 524 525 526 527 528 529 530 531 |
while (dio->bio_list) { unsigned long flags; struct bio *bio; int ret2; spin_lock_irqsave(&dio->bio_lock, flags); bio = dio->bio_list; dio->bio_list = bio->bi_private; spin_unlock_irqrestore(&dio->bio_lock, flags); ret2 = dio_bio_complete(dio, bio); if (ret == 0) ret = ret2; } |
eb28be2b4 direct-io: separa... |
532 |
sdio->reap_counter = 0; |
1da177e4c Linux-2.6.12-rc2 |
533 534 535 536 537 538 |
} return ret; } /* * Call into the fs to map some more disk blocks. We record the current number |
eb28be2b4 direct-io: separa... |
539 |
* of available blocks at sdio->blocks_available. These are in units of the |
1da177e4c Linux-2.6.12-rc2 |
540 541 542 543 544 |
* fs blocksize, (1 << inode->i_blkbits). * * The fs is allowed to map lots of blocks at once. If it wants to do that, * it uses the passed inode-relative block number as the file offset, as usual. * |
1d8fa7a2b [PATCH] remove ->... |
545 |
* get_block() is passed the number of i_blkbits-sized blocks which direct_io |
1da177e4c Linux-2.6.12-rc2 |
546 547 548 549 550 551 552 553 554 555 556 557 |
* has remaining to do. The fs should not map more than this number of blocks. * * If the fs has mapped a lot of blocks, it should populate bh->b_size to * indicate how much contiguous disk space has been made available at * bh->b_blocknr. * * If *any* of the mapped blocks are new, then the fs must set buffer_new(). * This isn't very efficient... * * In the case of filesystem holes: the fs may return an arbitrarily-large * hole by returning an appropriate value in b_size and by clearing * buffer_mapped(). However the direct-io code will only process holes one |
1d8fa7a2b [PATCH] remove ->... |
558 |
* block at a time - it will repeatedly call get_block() as it walks the hole. |
1da177e4c Linux-2.6.12-rc2 |
559 |
*/ |
18772641d direct-io: separa... |
560 561 |
static int get_more_blocks(struct dio *dio, struct dio_submit *sdio, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
562 563 |
{ int ret; |
1da177e4c Linux-2.6.12-rc2 |
564 |
sector_t fs_startblk; /* Into file, in filesystem-sized blocks */ |
ae55e1aaa fs/direct-io.c: c... |
565 |
sector_t fs_endblk; /* Into file, in filesystem-sized blocks */ |
1da177e4c Linux-2.6.12-rc2 |
566 |
unsigned long fs_count; /* Number of filesystem-sized blocks */ |
1da177e4c Linux-2.6.12-rc2 |
567 568 569 570 571 572 573 574 |
int create; /* * If there was a memory error and we've overwritten all the * mapped blocks then we can now return that memory error */ ret = dio->page_errors; if (ret == 0) { |
eb28be2b4 direct-io: separa... |
575 576 |
BUG_ON(sdio->block_in_file >= sdio->final_block_in_request); fs_startblk = sdio->block_in_file >> sdio->blkfactor; |
ae55e1aaa fs/direct-io.c: c... |
577 578 579 |
fs_endblk = (sdio->final_block_in_request - 1) >> sdio->blkfactor; fs_count = fs_endblk - fs_startblk + 1; |
1da177e4c Linux-2.6.12-rc2 |
580 |
|
3c674e742 Fixes a regressio... |
581 582 |
map_bh->b_state = 0; map_bh->b_size = fs_count << dio->inode->i_blkbits; |
5fe878ae7 direct-io: cleanu... |
583 584 585 586 587 588 589 590 591 592 593 |
/* * For writes inside i_size on a DIO_SKIP_HOLES filesystem we * forbid block creations: only overwrites are permitted. * We will return early to the caller once we see an * unmapped buffer head returned, and the caller will fall * back to buffered I/O. * * Otherwise the decision is left to the get_blocks method, * which may decide to handle it or also return an unmapped * buffer head. */ |
b31dc66a5 [PATCH] Kill PF_S... |
594 |
create = dio->rw & WRITE; |
5fe878ae7 direct-io: cleanu... |
595 |
if (dio->flags & DIO_SKIP_HOLES) { |
eb28be2b4 direct-io: separa... |
596 597 |
if (sdio->block_in_file < (i_size_read(dio->inode) >> sdio->blkbits)) |
1da177e4c Linux-2.6.12-rc2 |
598 |
create = 0; |
1da177e4c Linux-2.6.12-rc2 |
599 |
} |
3c674e742 Fixes a regressio... |
600 |
|
eb28be2b4 direct-io: separa... |
601 |
ret = (*sdio->get_block)(dio->inode, fs_startblk, |
1da177e4c Linux-2.6.12-rc2 |
602 |
map_bh, create); |
18772641d direct-io: separa... |
603 604 605 |
/* Store for completion */ dio->private = map_bh->b_private; |
1da177e4c Linux-2.6.12-rc2 |
606 607 608 609 610 611 612 |
} return ret; } /* * There is no bio. Make one now. */ |
ba253fbf6 direct-io: inline... |
613 614 |
static inline int dio_new_bio(struct dio *dio, struct dio_submit *sdio, sector_t start_sector, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
615 616 617 |
{ sector_t sector; int ret, nr_pages; |
eb28be2b4 direct-io: separa... |
618 |
ret = dio_bio_reap(dio, sdio); |
1da177e4c Linux-2.6.12-rc2 |
619 620 |
if (ret) goto out; |
eb28be2b4 direct-io: separa... |
621 |
sector = start_sector << (sdio->blkbits - 9); |
18772641d direct-io: separa... |
622 |
nr_pages = min(sdio->pages_in_io, bio_get_nr_vecs(map_bh->b_bdev)); |
20d9600cb fs/direct-io.c: d... |
623 |
nr_pages = min(nr_pages, BIO_MAX_PAGES); |
1da177e4c Linux-2.6.12-rc2 |
624 |
BUG_ON(nr_pages <= 0); |
18772641d direct-io: separa... |
625 |
dio_bio_alloc(dio, sdio, map_bh->b_bdev, sector, nr_pages); |
eb28be2b4 direct-io: separa... |
626 |
sdio->boundary = 0; |
1da177e4c Linux-2.6.12-rc2 |
627 628 629 630 631 632 633 634 635 636 637 |
out: return ret; } /* * Attempt to put the current chunk of 'cur_page' into the current BIO. If * that was successful then update final_block_in_bio and take a ref against * the just-added page. * * Return zero on success. Non-zero means the caller needs to start a new BIO. */ |
ba253fbf6 direct-io: inline... |
638 |
static inline int dio_bio_add_page(struct dio_submit *sdio) |
1da177e4c Linux-2.6.12-rc2 |
639 640 |
{ int ret; |
eb28be2b4 direct-io: separa... |
641 642 643 |
ret = bio_add_page(sdio->bio, sdio->cur_page, sdio->cur_page_len, sdio->cur_page_offset); if (ret == sdio->cur_page_len) { |
1da177e4c Linux-2.6.12-rc2 |
644 645 646 |
/* * Decrement count only, if we are done with this page */ |
eb28be2b4 direct-io: separa... |
647 648 649 650 651 |
if ((sdio->cur_page_len + sdio->cur_page_offset) == PAGE_SIZE) sdio->pages_in_io--; page_cache_get(sdio->cur_page); sdio->final_block_in_bio = sdio->cur_page_block + (sdio->cur_page_len >> sdio->blkbits); |
1da177e4c Linux-2.6.12-rc2 |
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 |
ret = 0; } else { ret = 1; } return ret; } /* * Put cur_page under IO. The section of cur_page which is described by * cur_page_offset,cur_page_len is put into a BIO. The section of cur_page * starts on-disk at cur_page_block. * * We take a ref against the page here (on behalf of its presence in the bio). * * The caller of this function is responsible for removing cur_page from the * dio, and for dropping the refcount which came from that presence. */ |
ba253fbf6 direct-io: inline... |
669 670 |
static inline int dio_send_cur_page(struct dio *dio, struct dio_submit *sdio, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
671 672 |
{ int ret = 0; |
eb28be2b4 direct-io: separa... |
673 674 675 676 |
if (sdio->bio) { loff_t cur_offset = sdio->cur_page_fs_offset; loff_t bio_next_offset = sdio->logical_offset_in_bio + sdio->bio->bi_size; |
c2c6ca417 direct-io: do not... |
677 |
|
1da177e4c Linux-2.6.12-rc2 |
678 |
/* |
c2c6ca417 direct-io: do not... |
679 680 |
* See whether this new request is contiguous with the old. * |
f0940cee2 dio: fix typos in... |
681 682 |
* Btrfs cannot handle having logically non-contiguous requests * submitted. For example if you have |
c2c6ca417 direct-io: do not... |
683 684 |
* * Logical: [0-4095][HOLE][8192-12287] |
f0940cee2 dio: fix typos in... |
685 |
* Physical: [0-4095] [4096-8191] |
c2c6ca417 direct-io: do not... |
686 687 688 689 690 |
* * We cannot submit those pages together as one BIO. So if our * current logical offset in the file does not equal what would * be the next logical offset in the bio, submit the bio we * have. |
1da177e4c Linux-2.6.12-rc2 |
691 |
*/ |
eb28be2b4 direct-io: separa... |
692 |
if (sdio->final_block_in_bio != sdio->cur_page_block || |
c2c6ca417 direct-io: do not... |
693 |
cur_offset != bio_next_offset) |
eb28be2b4 direct-io: separa... |
694 |
dio_bio_submit(dio, sdio); |
1da177e4c Linux-2.6.12-rc2 |
695 696 697 698 |
/* * Submit now if the underlying fs is about to perform a * metadata read */ |
eb28be2b4 direct-io: separa... |
699 700 |
else if (sdio->boundary) dio_bio_submit(dio, sdio); |
1da177e4c Linux-2.6.12-rc2 |
701 |
} |
eb28be2b4 direct-io: separa... |
702 |
if (sdio->bio == NULL) { |
18772641d direct-io: separa... |
703 |
ret = dio_new_bio(dio, sdio, sdio->cur_page_block, map_bh); |
1da177e4c Linux-2.6.12-rc2 |
704 705 706 |
if (ret) goto out; } |
eb28be2b4 direct-io: separa... |
707 708 |
if (dio_bio_add_page(sdio) != 0) { dio_bio_submit(dio, sdio); |
18772641d direct-io: separa... |
709 |
ret = dio_new_bio(dio, sdio, sdio->cur_page_block, map_bh); |
1da177e4c Linux-2.6.12-rc2 |
710 |
if (ret == 0) { |
eb28be2b4 direct-io: separa... |
711 |
ret = dio_bio_add_page(sdio); |
1da177e4c Linux-2.6.12-rc2 |
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 |
BUG_ON(ret != 0); } } out: return ret; } /* * An autonomous function to put a chunk of a page under deferred IO. * * The caller doesn't actually know (or care) whether this piece of page is in * a BIO, or is under IO or whatever. We just take care of all possible * situations here. The separation between the logic of do_direct_IO() and * that of submit_page_section() is important for clarity. Please don't break. * * The chunk of page starts on-disk at blocknr. * * We perform deferred IO, by recording the last-submitted page inside our * private part of the dio structure. If possible, we just expand the IO * across that page here. * * If that doesn't work out then we put the old page into the bio and add this * page to the dio instead. */ |
ba253fbf6 direct-io: inline... |
736 |
static inline int |
eb28be2b4 direct-io: separa... |
737 |
submit_page_section(struct dio *dio, struct dio_submit *sdio, struct page *page, |
18772641d direct-io: separa... |
738 739 |
unsigned offset, unsigned len, sector_t blocknr, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
740 741 |
{ int ret = 0; |
98c4d57de [PATCH] io-accoun... |
742 743 744 745 746 747 |
if (dio->rw & WRITE) { /* * Read accounting is performed in submit_bio() */ task_io_account_write(len); } |
1da177e4c Linux-2.6.12-rc2 |
748 749 750 |
/* * Can we just grow the current page's presence in the dio? */ |
eb28be2b4 direct-io: separa... |
751 752 753 754 755 |
if (sdio->cur_page == page && sdio->cur_page_offset + sdio->cur_page_len == offset && sdio->cur_page_block + (sdio->cur_page_len >> sdio->blkbits) == blocknr) { sdio->cur_page_len += len; |
1da177e4c Linux-2.6.12-rc2 |
756 757 |
/* |
eb28be2b4 direct-io: separa... |
758 |
* If sdio->boundary then we want to schedule the IO now to |
1da177e4c Linux-2.6.12-rc2 |
759 760 |
* avoid metadata seeks. */ |
eb28be2b4 direct-io: separa... |
761 |
if (sdio->boundary) { |
18772641d direct-io: separa... |
762 |
ret = dio_send_cur_page(dio, sdio, map_bh); |
eb28be2b4 direct-io: separa... |
763 764 |
page_cache_release(sdio->cur_page); sdio->cur_page = NULL; |
1da177e4c Linux-2.6.12-rc2 |
765 766 767 768 769 770 771 |
} goto out; } /* * If there's a deferred page already there then send it. */ |
eb28be2b4 direct-io: separa... |
772 |
if (sdio->cur_page) { |
18772641d direct-io: separa... |
773 |
ret = dio_send_cur_page(dio, sdio, map_bh); |
eb28be2b4 direct-io: separa... |
774 775 |
page_cache_release(sdio->cur_page); sdio->cur_page = NULL; |
1da177e4c Linux-2.6.12-rc2 |
776 777 778 779 780 |
if (ret) goto out; } page_cache_get(page); /* It is in dio */ |
eb28be2b4 direct-io: separa... |
781 782 783 784 785 |
sdio->cur_page = page; sdio->cur_page_offset = offset; sdio->cur_page_len = len; sdio->cur_page_block = blocknr; sdio->cur_page_fs_offset = sdio->block_in_file << sdio->blkbits; |
1da177e4c Linux-2.6.12-rc2 |
786 787 788 789 790 791 792 793 794 |
out: return ret; } /* * Clean any dirty buffers in the blockdev mapping which alias newly-created * file blocks. Only called for S_ISREG files - blockdevs do not set * buffer_new */ |
18772641d direct-io: separa... |
795 |
static void clean_blockdev_aliases(struct dio *dio, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
796 797 798 |
{ unsigned i; unsigned nblocks; |
18772641d direct-io: separa... |
799 |
nblocks = map_bh->b_size >> dio->inode->i_blkbits; |
1da177e4c Linux-2.6.12-rc2 |
800 801 |
for (i = 0; i < nblocks; i++) { |
18772641d direct-io: separa... |
802 803 |
unmap_underlying_metadata(map_bh->b_bdev, map_bh->b_blocknr + i); |
1da177e4c Linux-2.6.12-rc2 |
804 805 806 807 808 809 810 811 812 813 814 815 |
} } /* * If we are not writing the entire block and get_block() allocated * the block for us, we need to fill-in the unused portion of the * block with zeros. This happens only if user-buffer, fileoffset or * io length is not filesystem block-size multiple. * * `end' is zero if we're doing the start of the IO, 1 at the end of the * IO. */ |
ba253fbf6 direct-io: inline... |
816 817 |
static inline void dio_zero_block(struct dio *dio, struct dio_submit *sdio, int end, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
818 819 820 821 822 |
{ unsigned dio_blocks_per_fs_block; unsigned this_chunk_blocks; /* In dio_blocks */ unsigned this_chunk_bytes; struct page *page; |
eb28be2b4 direct-io: separa... |
823 |
sdio->start_zero_done = 1; |
18772641d direct-io: separa... |
824 |
if (!sdio->blkfactor || !buffer_new(map_bh)) |
1da177e4c Linux-2.6.12-rc2 |
825 |
return; |
eb28be2b4 direct-io: separa... |
826 827 |
dio_blocks_per_fs_block = 1 << sdio->blkfactor; this_chunk_blocks = sdio->block_in_file & (dio_blocks_per_fs_block - 1); |
1da177e4c Linux-2.6.12-rc2 |
828 829 830 831 832 833 834 835 836 837 |
if (!this_chunk_blocks) return; /* * We need to zero out part of an fs block. It is either at the * beginning or the end of the fs block. */ if (end) this_chunk_blocks = dio_blocks_per_fs_block - this_chunk_blocks; |
eb28be2b4 direct-io: separa... |
838 |
this_chunk_bytes = this_chunk_blocks << sdio->blkbits; |
1da177e4c Linux-2.6.12-rc2 |
839 |
|
557ed1fa2 remove ZERO_PAGE |
840 |
page = ZERO_PAGE(0); |
eb28be2b4 direct-io: separa... |
841 |
if (submit_page_section(dio, sdio, page, 0, this_chunk_bytes, |
18772641d direct-io: separa... |
842 |
sdio->next_block_for_io, map_bh)) |
1da177e4c Linux-2.6.12-rc2 |
843 |
return; |
eb28be2b4 direct-io: separa... |
844 |
sdio->next_block_for_io += this_chunk_blocks; |
1da177e4c Linux-2.6.12-rc2 |
845 846 847 848 849 850 851 852 853 854 855 |
} /* * Walk the user pages, and the file, mapping blocks to disk and generating * a sequence of (page,offset,len,block) mappings. These mappings are injected * into submit_page_section(), which takes care of the next stage of submission * * Direct IO against a blockdev is different from a file. Because we can * happily perform page-sized but 512-byte aligned IOs. It is important that * blockdev IO be able to have fine alignment and large sizes. * |
1d8fa7a2b [PATCH] remove ->... |
856 |
* So what we do is to permit the ->get_block function to populate bh.b_size |
1da177e4c Linux-2.6.12-rc2 |
857 858 859 |
* with the size of IO which is permitted at this offset and this i_blkbits. * * For best results, the blockdev should be set up with 512-byte i_blkbits and |
1d8fa7a2b [PATCH] remove ->... |
860 |
* it should set b_size to PAGE_SIZE or more inside get_block(). This gives |
1da177e4c Linux-2.6.12-rc2 |
861 862 |
* fine alignment but still allows this function to work in PAGE_SIZE units. */ |
18772641d direct-io: separa... |
863 864 |
static int do_direct_IO(struct dio *dio, struct dio_submit *sdio, struct buffer_head *map_bh) |
1da177e4c Linux-2.6.12-rc2 |
865 |
{ |
eb28be2b4 direct-io: separa... |
866 |
const unsigned blkbits = sdio->blkbits; |
1da177e4c Linux-2.6.12-rc2 |
867 868 869 |
const unsigned blocks_per_page = PAGE_SIZE >> blkbits; struct page *page; unsigned block_in_page; |
1da177e4c Linux-2.6.12-rc2 |
870 871 872 |
int ret = 0; /* The I/O can start at any block offset within the first page */ |
eb28be2b4 direct-io: separa... |
873 |
block_in_page = sdio->first_block_in_page; |
1da177e4c Linux-2.6.12-rc2 |
874 |
|
eb28be2b4 direct-io: separa... |
875 876 |
while (sdio->block_in_file < sdio->final_block_in_request) { page = dio_get_page(dio, sdio); |
1da177e4c Linux-2.6.12-rc2 |
877 878 879 880 881 882 883 884 885 886 |
if (IS_ERR(page)) { ret = PTR_ERR(page); goto out; } while (block_in_page < blocks_per_page) { unsigned offset_in_page = block_in_page << blkbits; unsigned this_chunk_bytes; /* # of bytes mapped */ unsigned this_chunk_blocks; /* # of blocks */ unsigned u; |
eb28be2b4 direct-io: separa... |
887 |
if (sdio->blocks_available == 0) { |
1da177e4c Linux-2.6.12-rc2 |
888 889 890 891 892 |
/* * Need to go and map some more disk */ unsigned long blkmask; unsigned long dio_remainder; |
18772641d direct-io: separa... |
893 |
ret = get_more_blocks(dio, sdio, map_bh); |
1da177e4c Linux-2.6.12-rc2 |
894 895 896 897 898 899 |
if (ret) { page_cache_release(page); goto out; } if (!buffer_mapped(map_bh)) goto do_holes; |
eb28be2b4 direct-io: separa... |
900 901 902 903 |
sdio->blocks_available = map_bh->b_size >> sdio->blkbits; sdio->next_block_for_io = map_bh->b_blocknr << sdio->blkfactor; |
1da177e4c Linux-2.6.12-rc2 |
904 |
if (buffer_new(map_bh)) |
18772641d direct-io: separa... |
905 |
clean_blockdev_aliases(dio, map_bh); |
1da177e4c Linux-2.6.12-rc2 |
906 |
|
eb28be2b4 direct-io: separa... |
907 |
if (!sdio->blkfactor) |
1da177e4c Linux-2.6.12-rc2 |
908 |
goto do_holes; |
eb28be2b4 direct-io: separa... |
909 910 |
blkmask = (1 << sdio->blkfactor) - 1; dio_remainder = (sdio->block_in_file & blkmask); |
1da177e4c Linux-2.6.12-rc2 |
911 912 913 914 915 916 917 918 919 920 921 922 923 |
/* * If we are at the start of IO and that IO * starts partway into a fs-block, * dio_remainder will be non-zero. If the IO * is a read then we can simply advance the IO * cursor to the first block which is to be * read. But if the IO is a write and the * block was newly allocated we cannot do that; * the start of the fs block must be zeroed out * on-disk */ if (!buffer_new(map_bh)) |
eb28be2b4 direct-io: separa... |
924 925 |
sdio->next_block_for_io += dio_remainder; sdio->blocks_available -= dio_remainder; |
1da177e4c Linux-2.6.12-rc2 |
926 927 928 929 |
} do_holes: /* Handle holes */ if (!buffer_mapped(map_bh)) { |
35dc8161d [PATCH] fix O_DIR... |
930 |
loff_t i_size_aligned; |
1da177e4c Linux-2.6.12-rc2 |
931 932 |
/* AKPM: eargh, -ENOTBLK is a hack */ |
b31dc66a5 [PATCH] Kill PF_S... |
933 |
if (dio->rw & WRITE) { |
1da177e4c Linux-2.6.12-rc2 |
934 935 936 |
page_cache_release(page); return -ENOTBLK; } |
35dc8161d [PATCH] fix O_DIR... |
937 938 939 940 941 942 |
/* * Be sure to account for a partial block as the * last block in the file */ i_size_aligned = ALIGN(i_size_read(dio->inode), 1 << blkbits); |
eb28be2b4 direct-io: separa... |
943 |
if (sdio->block_in_file >= |
35dc8161d [PATCH] fix O_DIR... |
944 |
i_size_aligned >> blkbits) { |
1da177e4c Linux-2.6.12-rc2 |
945 946 947 948 |
/* We hit eof */ page_cache_release(page); goto out; } |
eebd2aa35 Pagecache zeroing... |
949 950 |
zero_user(page, block_in_page << blkbits, 1 << blkbits); |
eb28be2b4 direct-io: separa... |
951 |
sdio->block_in_file++; |
1da177e4c Linux-2.6.12-rc2 |
952 953 954 955 956 957 958 959 960 |
block_in_page++; goto next_block; } /* * If we're performing IO which has an alignment which * is finer than the underlying fs, go check to see if * we must zero out the start of this block. */ |
eb28be2b4 direct-io: separa... |
961 |
if (unlikely(sdio->blkfactor && !sdio->start_zero_done)) |
18772641d direct-io: separa... |
962 |
dio_zero_block(dio, sdio, 0, map_bh); |
1da177e4c Linux-2.6.12-rc2 |
963 964 965 966 967 |
/* * Work out, in this_chunk_blocks, how much disk we * can add to this page */ |
eb28be2b4 direct-io: separa... |
968 |
this_chunk_blocks = sdio->blocks_available; |
1da177e4c Linux-2.6.12-rc2 |
969 970 971 |
u = (PAGE_SIZE - offset_in_page) >> blkbits; if (this_chunk_blocks > u) this_chunk_blocks = u; |
eb28be2b4 direct-io: separa... |
972 |
u = sdio->final_block_in_request - sdio->block_in_file; |
1da177e4c Linux-2.6.12-rc2 |
973 974 975 976 |
if (this_chunk_blocks > u) this_chunk_blocks = u; this_chunk_bytes = this_chunk_blocks << blkbits; BUG_ON(this_chunk_bytes == 0); |
eb28be2b4 direct-io: separa... |
977 978 979 980 |
sdio->boundary = buffer_boundary(map_bh); ret = submit_page_section(dio, sdio, page, offset_in_page, this_chunk_bytes, |
18772641d direct-io: separa... |
981 982 |
sdio->next_block_for_io, map_bh); |
1da177e4c Linux-2.6.12-rc2 |
983 984 985 986 |
if (ret) { page_cache_release(page); goto out; } |
eb28be2b4 direct-io: separa... |
987 |
sdio->next_block_for_io += this_chunk_blocks; |
1da177e4c Linux-2.6.12-rc2 |
988 |
|
eb28be2b4 direct-io: separa... |
989 |
sdio->block_in_file += this_chunk_blocks; |
1da177e4c Linux-2.6.12-rc2 |
990 |
block_in_page += this_chunk_blocks; |
eb28be2b4 direct-io: separa... |
991 |
sdio->blocks_available -= this_chunk_blocks; |
1da177e4c Linux-2.6.12-rc2 |
992 |
next_block: |
eb28be2b4 direct-io: separa... |
993 994 |
BUG_ON(sdio->block_in_file > sdio->final_block_in_request); if (sdio->block_in_file == sdio->final_block_in_request) |
1da177e4c Linux-2.6.12-rc2 |
995 996 997 998 999 1000 1001 1002 1003 1004 |
break; } /* Drop the ref which was taken in get_user_pages() */ page_cache_release(page); block_in_page = 0; } out: return ret; } |
847cc6371 direct-io: merge ... |
1005 |
static inline int drop_refcount(struct dio *dio) |
1da177e4c Linux-2.6.12-rc2 |
1006 |
{ |
847cc6371 direct-io: merge ... |
1007 |
int ret2; |
5eb6c7a2a [PATCH] dio: lock... |
1008 |
unsigned long flags; |
1da177e4c Linux-2.6.12-rc2 |
1009 |
|
8459d86af [PATCH] dio: only... |
1010 1011 |
/* * Sync will always be dropping the final ref and completing the |
5eb6c7a2a [PATCH] dio: lock... |
1012 1013 1014 1015 1016 1017 1018 1019 |
* operation. AIO can if it was a broken operation described above or * in fact if all the bios race to complete before we get here. In * that case dio_complete() translates the EIOCBQUEUED into the proper * return code that the caller will hand to aio_complete(). * * This is managed by the bio_lock instead of being an atomic_t so that * completion paths can drop their ref and use the remaining count to * decide to wake the submission path atomically. |
8459d86af [PATCH] dio: only... |
1020 |
*/ |
5eb6c7a2a [PATCH] dio: lock... |
1021 1022 1023 |
spin_lock_irqsave(&dio->bio_lock, flags); ret2 = --dio->refcount; spin_unlock_irqrestore(&dio->bio_lock, flags); |
847cc6371 direct-io: merge ... |
1024 |
return ret2; |
1da177e4c Linux-2.6.12-rc2 |
1025 |
} |
eafdc7d19 sort out blockdev... |
1026 1027 1028 1029 1030 1031 1032 1033 1034 |
/* * This is a library function for use by filesystem drivers. * * The locking rules are governed by the flags parameter: * - if the flags value contains DIO_LOCKING we use a fancy locking * scheme for dumb filesystems. * For writes this function is called under i_mutex and returns with * i_mutex held, for reads, i_mutex is not held on entry, but it is * taken and dropped again before returning. |
eafdc7d19 sort out blockdev... |
1035 1036 1037 |
* - if the flags value does NOT contain DIO_LOCKING we don't use any * internal locking but rather rely on the filesystem to synchronize * direct I/O reads/writes versus each other and truncate. |
df2d6f265 fs: always mainta... |
1038 1039 1040 1041 1042 1043 1044 |
* * To help with locking against truncate we incremented the i_dio_count * counter before starting direct I/O, and decrement it once we are done. * Truncate can wait for it to reach zero to provide exclusion. It is * expected that filesystem provide exclusion between new direct I/O * and truncates. For DIO_LOCKING filesystems this is done by i_mutex, * but other filesystems need to take care of this on their own. |
ba253fbf6 direct-io: inline... |
1045 1046 1047 1048 1049 |
* * NOTE: if you pass "sdio" to anything by pointer make sure that function * is always inlined. Otherwise gcc is unable to split the structure into * individual fields and will generate much worse code. This is important * for the whole file. |
eafdc7d19 sort out blockdev... |
1050 |
*/ |
65dd2aa90 dio: optimize cac... |
1051 1052 |
static inline ssize_t do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode, |
1da177e4c Linux-2.6.12-rc2 |
1053 |
struct block_device *bdev, const struct iovec *iov, loff_t offset, |
1d8fa7a2b [PATCH] remove ->... |
1054 |
unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io, |
facd07b07 direct-io: add a ... |
1055 |
dio_submit_t submit_io, int flags) |
1da177e4c Linux-2.6.12-rc2 |
1056 1057 1058 1059 1060 |
{ int seg; size_t size; unsigned long addr; unsigned blkbits = inode->i_blkbits; |
1da177e4c Linux-2.6.12-rc2 |
1061 1062 1063 1064 |
unsigned blocksize_mask = (1 << blkbits) - 1; ssize_t retval = -EINVAL; loff_t end = offset; struct dio *dio; |
eb28be2b4 direct-io: separa... |
1065 |
struct dio_submit sdio = { 0, }; |
847cc6371 direct-io: merge ... |
1066 1067 1068 |
unsigned long user_addr; size_t bytes; struct buffer_head map_bh = { 0, }; |
1da177e4c Linux-2.6.12-rc2 |
1069 1070 |
if (rw & WRITE) |
721a9602e block: kill off R... |
1071 |
rw = WRITE_ODIRECT; |
1da177e4c Linux-2.6.12-rc2 |
1072 |
|
65dd2aa90 dio: optimize cac... |
1073 1074 1075 1076 |
/* * Avoid references to bdev if not absolutely needed to give * the early prefetch in the caller enough time. */ |
1da177e4c Linux-2.6.12-rc2 |
1077 1078 1079 |
if (offset & blocksize_mask) { if (bdev) |
65dd2aa90 dio: optimize cac... |
1080 |
blkbits = blksize_bits(bdev_logical_block_size(bdev)); |
1da177e4c Linux-2.6.12-rc2 |
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 |
blocksize_mask = (1 << blkbits) - 1; if (offset & blocksize_mask) goto out; } /* Check the memory alignment. Blocks cannot straddle pages */ for (seg = 0; seg < nr_segs; seg++) { addr = (unsigned long)iov[seg].iov_base; size = iov[seg].iov_len; end += size; |
65dd2aa90 dio: optimize cac... |
1091 1092 |
if (unlikely((addr & blocksize_mask) || (size & blocksize_mask))) { |
1da177e4c Linux-2.6.12-rc2 |
1093 |
if (bdev) |
65dd2aa90 dio: optimize cac... |
1094 1095 |
blkbits = blksize_bits( bdev_logical_block_size(bdev)); |
1da177e4c Linux-2.6.12-rc2 |
1096 |
blocksize_mask = (1 << blkbits) - 1; |
65dd2aa90 dio: optimize cac... |
1097 |
if ((addr & blocksize_mask) || (size & blocksize_mask)) |
1da177e4c Linux-2.6.12-rc2 |
1098 1099 1100 |
goto out; } } |
f9b5570d7 fs: simplify hand... |
1101 1102 1103 |
/* watch out for a 0 len io from a tricksy fs */ if (rw == READ && end == offset) return 0; |
6e8267f53 direct-io: use a ... |
1104 |
dio = kmem_cache_alloc(dio_cache, GFP_KERNEL); |
1da177e4c Linux-2.6.12-rc2 |
1105 1106 1107 |
retval = -ENOMEM; if (!dio) goto out; |
23aee091d dio: don't zero o... |
1108 1109 1110 1111 1112 1113 |
/* * Believe it or not, zeroing out the page array caused a .5% * performance regression in a database benchmark. So, we take * care to only zero out what's needed. */ memset(dio, 0, offsetof(struct dio, pages)); |
1da177e4c Linux-2.6.12-rc2 |
1114 |
|
5fe878ae7 direct-io: cleanu... |
1115 1116 |
dio->flags = flags; if (dio->flags & DIO_LOCKING) { |
f9b5570d7 fs: simplify hand... |
1117 |
if (rw == READ) { |
5fe878ae7 direct-io: cleanu... |
1118 1119 |
struct address_space *mapping = iocb->ki_filp->f_mapping; |
1da177e4c Linux-2.6.12-rc2 |
1120 |
|
5fe878ae7 direct-io: cleanu... |
1121 1122 |
/* will be released by direct_io_worker */ mutex_lock(&inode->i_mutex); |
1da177e4c Linux-2.6.12-rc2 |
1123 1124 1125 1126 |
retval = filemap_write_and_wait_range(mapping, offset, end - 1); if (retval) { |
5fe878ae7 direct-io: cleanu... |
1127 |
mutex_unlock(&inode->i_mutex); |
6e8267f53 direct-io: use a ... |
1128 |
kmem_cache_free(dio_cache, dio); |
1da177e4c Linux-2.6.12-rc2 |
1129 1130 |
goto out; } |
1da177e4c Linux-2.6.12-rc2 |
1131 |
} |
1da177e4c Linux-2.6.12-rc2 |
1132 1133 1134 |
} /* |
df2d6f265 fs: always mainta... |
1135 1136 1137 1138 1139 |
* Will be decremented at I/O completion time. */ atomic_inc(&inode->i_dio_count); /* |
1da177e4c Linux-2.6.12-rc2 |
1140 1141 1142 1143 1144 |
* For file extending writes updating i_size before data * writeouts complete can expose uninitialized blocks. So * even for AIO, we need to wait for i/o to complete before * returning in this case. */ |
b31dc66a5 [PATCH] Kill PF_S... |
1145 |
dio->is_async = !is_sync_kiocb(iocb) && !((rw & WRITE) && |
1da177e4c Linux-2.6.12-rc2 |
1146 |
(end > i_size_read(inode))); |
847cc6371 direct-io: merge ... |
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 |
retval = 0; dio->inode = inode; dio->rw = rw; sdio.blkbits = blkbits; sdio.blkfactor = inode->i_blkbits - blkbits; sdio.block_in_file = offset >> blkbits; sdio.get_block = get_block; dio->end_io = end_io; sdio.submit_io = submit_io; sdio.final_block_in_bio = -1; sdio.next_block_for_io = -1; dio->iocb = iocb; dio->i_size = i_size_read(inode); spin_lock_init(&dio->bio_lock); dio->refcount = 1; /* * In case of non-aligned buffers, we may need 2 more * pages since we need to zero out first and last block. */ if (unlikely(sdio.blkfactor)) sdio.pages_in_io = 2; for (seg = 0; seg < nr_segs; seg++) { user_addr = (unsigned long)iov[seg].iov_base; sdio.pages_in_io += ((user_addr + iov[seg].iov_len + PAGE_SIZE-1) / PAGE_SIZE - user_addr / PAGE_SIZE); } for (seg = 0; seg < nr_segs; seg++) { user_addr = (unsigned long)iov[seg].iov_base; sdio.size += bytes = iov[seg].iov_len; /* Index into the first page of the first block */ sdio.first_block_in_page = (user_addr & ~PAGE_MASK) >> blkbits; sdio.final_block_in_request = sdio.block_in_file + (bytes >> blkbits); /* Page fetching state */ sdio.head = 0; sdio.tail = 0; sdio.curr_page = 0; sdio.total_pages = 0; if (user_addr & (PAGE_SIZE-1)) { sdio.total_pages++; bytes -= PAGE_SIZE - (user_addr & (PAGE_SIZE - 1)); } sdio.total_pages += (bytes + PAGE_SIZE - 1) / PAGE_SIZE; sdio.curr_user_address = user_addr; retval = do_direct_IO(dio, &sdio, &map_bh); dio->result += iov[seg].iov_len - ((sdio.final_block_in_request - sdio.block_in_file) << blkbits); if (retval) { dio_cleanup(dio, &sdio); break; } } /* end iovec loop */ if (retval == -ENOTBLK) { /* * The remaining part of the request will be * be handled by buffered I/O when we return */ retval = 0; } /* * There may be some unwritten disk at the end of a part-written * fs-block-sized block. Go zero that now. */ dio_zero_block(dio, &sdio, 1, &map_bh); if (sdio.cur_page) { ssize_t ret2; ret2 = dio_send_cur_page(dio, &sdio, &map_bh); if (retval == 0) retval = ret2; page_cache_release(sdio.cur_page); sdio.cur_page = NULL; } if (sdio.bio) dio_bio_submit(dio, &sdio); /* * It is possible that, we return short IO due to end of file. * In that case, we need to release all the pages we got hold on. */ dio_cleanup(dio, &sdio); /* * All block lookups have been performed. For READ requests * we can let i_mutex go now that its achieved its purpose * of protecting us from looking up uninitialized blocks. */ if (rw == READ && (dio->flags & DIO_LOCKING)) mutex_unlock(&dio->inode->i_mutex); /* * The only time we want to leave bios in flight is when a successful * partial aio read or full aio write have been setup. In that case * bio completion will call aio_complete. The only time it's safe to * call aio_complete is when we return -EIOCBQUEUED, so we key on that. * This had *better* be the only place that raises -EIOCBQUEUED. */ BUG_ON(retval == -EIOCBQUEUED); if (dio->is_async && retval == 0 && dio->result && ((rw & READ) || (dio->result == sdio.size))) retval = -EIOCBQUEUED; if (retval != -EIOCBQUEUED) dio_await_completion(dio); if (drop_refcount(dio) == 0) { retval = dio_complete(dio, offset, retval, false); kmem_cache_free(dio_cache, dio); } else BUG_ON(retval != -EIOCBQUEUED); |
1da177e4c Linux-2.6.12-rc2 |
1273 |
|
7bb46a673 fs: introduce new... |
1274 1275 1276 |
out: return retval; } |
65dd2aa90 dio: optimize cac... |
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 |
ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode, struct block_device *bdev, const struct iovec *iov, loff_t offset, unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io, dio_submit_t submit_io, int flags) { /* * The block device state is needed in the end to finally * submit everything. Since it's likely to be cache cold * prefetch it here as first thing to hide some of the * latency. * * Attempt to prefetch the pieces we likely need later. */ prefetch(&bdev->bd_disk->part_tbl); prefetch(bdev->bd_queue); prefetch((char *)bdev->bd_queue + SMP_CACHE_BYTES); return do_blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset, nr_segs, get_block, end_io, submit_io, flags); } |
1da177e4c Linux-2.6.12-rc2 |
1300 |
EXPORT_SYMBOL(__blockdev_direct_IO); |
6e8267f53 direct-io: use a ... |
1301 1302 1303 1304 1305 1306 1307 |
static __init int dio_init(void) { dio_cache = KMEM_CACHE(dio, SLAB_PANIC); return 0; } module_init(dio_init) |