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