direct-io.c 39.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 * fs/direct-io.c
 *
 * Copyright (C) 2002, Linus Torvalds.
 *
 * O_DIRECT
 *
8
 * 04Jul2002	Andrew Morton
L
Linus Torvalds 已提交
9 10 11
 *		Initial version
 * 11Sep2002	janetinc@us.ibm.com
 * 		added readv/writev support.
12
 * 29Oct2002	Andrew Morton
L
Linus Torvalds 已提交
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>
A
Andrew Morton 已提交
30
#include <linux/task_io_accounting_ops.h>
L
Linus Torvalds 已提交
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>
A
Arun Sharma 已提交
38
#include <linux/atomic.h>
39
#include <linux/prefetch.h>
40
#include <linux/aio.h>
L
Linus Torvalds 已提交
41 42 43

/*
 * How many user pages to map in one call to get_user_pages().  This determines
A
Andi Kleen 已提交
44
 * the size of a structure in the slab cache
L
Linus Torvalds 已提交
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
 */
#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.
 */

60 61 62
/* dio_state only used in the submission path */

struct dio_submit {
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
	struct bio *bio;		/* bio under assembly */
	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 */
78
	int reap_counter;		/* rate limit reaping */
L
Linus Torvalds 已提交
79 80 81
	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 */
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 */
L
Linus Torvalds 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98
	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 */

	/*
	 * 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 */
99
	loff_t cur_page_fs_offset;	/* Offset in file */
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113

	/*
	 * 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().
	 */
	unsigned head;			/* next page to process */
	unsigned tail;			/* last valid page + 1 */
114 115 116 117 118 119
};

/* dio_state communicated between submission path and end_io */
struct dio {
	int flags;			/* doesn't change */
	int rw;
120
	struct inode *inode;
121 122 123
	loff_t i_size;			/* i_size when submitted */
	dio_iodone_t *end_io;		/* IO completion function */

A
Andi Kleen 已提交
124
	void *private;			/* copy from map_bh.b_private */
125 126 127

	/* BIO completion state */
	spinlock_t bio_lock;		/* protects BIO fields below */
128 129
	int page_errors;		/* errno from get_user_pages() */
	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 133 134 135 136 137 138 139
	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 */
	ssize_t result;                 /* IO result */

140 141 142 143 144
	/*
	 * 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.
	 */
145 146 147 148
	union {
		struct page *pages[DIO_PAGES];	/* page buffer */
		struct work_struct complete_work;/* deferred AIO completion */
	};
149 150 151
} ____cacheline_aligned_in_smp;

static struct kmem_cache *dio_cache __read_mostly;
L
Linus Torvalds 已提交
152 153 154 155

/*
 * How many pages are in the queue?
 */
156
static inline unsigned dio_pages_present(struct dio_submit *sdio)
L
Linus Torvalds 已提交
157
{
158
	return sdio->tail - sdio->head;
L
Linus Torvalds 已提交
159 160 161 162 163
}

/*
 * Go grab and pin some userspace pages.   Typically we'll get 64 at a time.
 */
164
static inline int dio_refill_pages(struct dio *dio, struct dio_submit *sdio)
L
Linus Torvalds 已提交
165 166 167 168
{
	int ret;
	int nr_pages;

169
	nr_pages = min(sdio->total_pages - sdio->curr_page, DIO_PAGES);
N
Nick Piggin 已提交
170
	ret = get_user_pages_fast(
171
		sdio->curr_user_address,		/* Where from? */
L
Linus Torvalds 已提交
172 173
		nr_pages,			/* How many pages? */
		dio->rw == READ,		/* Write to memory? */
N
Nick Piggin 已提交
174
		&dio->pages[0]);		/* Put results here */
L
Linus Torvalds 已提交
175

176
	if (ret < 0 && sdio->blocks_available && (dio->rw & WRITE)) {
N
Nick Piggin 已提交
177
		struct page *page = ZERO_PAGE(0);
L
Linus Torvalds 已提交
178 179 180 181 182 183 184
		/*
		 * 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;
N
Nick Piggin 已提交
185 186
		page_cache_get(page);
		dio->pages[0] = page;
187 188
		sdio->head = 0;
		sdio->tail = 1;
L
Linus Torvalds 已提交
189 190 191 192 193
		ret = 0;
		goto out;
	}

	if (ret >= 0) {
194 195 196 197
		sdio->curr_user_address += ret * PAGE_SIZE;
		sdio->curr_page += ret;
		sdio->head = 0;
		sdio->tail = ret;
L
Linus Torvalds 已提交
198 199 200 201 202 203 204 205 206 207 208 209
		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.
 */
210 211
static inline struct page *dio_get_page(struct dio *dio,
		struct dio_submit *sdio)
L
Linus Torvalds 已提交
212
{
213
	if (dio_pages_present(sdio) == 0) {
L
Linus Torvalds 已提交
214 215
		int ret;

216
		ret = dio_refill_pages(dio, sdio);
L
Linus Torvalds 已提交
217 218
		if (ret)
			return ERR_PTR(ret);
219
		BUG_ON(dio_pages_present(sdio) == 0);
L
Linus Torvalds 已提交
220
	}
221
	return dio->pages[sdio->head++];
L
Linus Torvalds 已提交
222 223
}

224 225 226 227
/**
 * dio_complete() - called when all DIO BIO I/O has been completed
 * @offset: the byte offset in the file of the completed operation
 *
228 229
 * This drops i_dio_count, lets interested parties know that a DIO operation
 * has completed, and calculates the resulting return code for the operation.
230 231 232 233 234
 *
 * 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.
L
Linus Torvalds 已提交
235
 */
236 237
static ssize_t dio_complete(struct dio *dio, loff_t offset, ssize_t ret,
		bool is_async)
L
Linus Torvalds 已提交
238
{
239 240
	ssize_t transferred = 0;

241 242 243 244 245 246 247 248 249
	/*
	 * 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;

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
	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;
	}

	if (ret == 0)
		ret = dio->page_errors;
	if (ret == 0)
		ret = dio->io_error;
	if (ret == 0)
		ret = transferred;

265 266 267 268
	if (dio->end_io && dio->result)
		dio->end_io(dio->iocb, offset, transferred, dio->private);

	inode_dio_done(dio->inode);
269 270 271 272 273 274 275 276 277 278
	if (is_async) {
		if (dio->rw & WRITE) {
			int err;

			err = generic_write_sync(dio->iocb->ki_filp, offset,
						 transferred);
			if (err < 0 && ret > 0)
				ret = err;
		}

279
		aio_complete(dio->iocb, ret, 0);
280
	}
281

282
	kmem_cache_free(dio_cache, dio);
283
	return ret;
L
Linus Torvalds 已提交
284 285
}

286 287 288 289 290 291 292
static void dio_aio_complete_work(struct work_struct *work)
{
	struct dio *dio = container_of(work, struct dio, complete_work);

	dio_complete(dio, dio->iocb->ki_pos, 0, true);
}

L
Linus Torvalds 已提交
293
static int dio_bio_complete(struct dio *dio, struct bio *bio);
294

L
Linus Torvalds 已提交
295 296 297
/*
 * Asynchronous IO callback. 
 */
298
static void dio_bio_end_aio(struct bio *bio, int error)
L
Linus Torvalds 已提交
299 300
{
	struct dio *dio = bio->bi_private;
Z
Zach Brown 已提交
301 302
	unsigned long remaining;
	unsigned long flags;
L
Linus Torvalds 已提交
303 304 305

	/* cleanup the bio */
	dio_bio_complete(dio, bio);
306

Z
Zach Brown 已提交
307 308 309
	spin_lock_irqsave(&dio->bio_lock, flags);
	remaining = --dio->refcount;
	if (remaining == 1 && dio->waiter)
310
		wake_up_process(dio->waiter);
Z
Zach Brown 已提交
311
	spin_unlock_irqrestore(&dio->bio_lock, flags);
312

313
	if (remaining == 0) {
314 315 316 317 318 319 320
		if (dio->result && dio->defer_completion) {
			INIT_WORK(&dio->complete_work, dio_aio_complete_work);
			queue_work(dio->inode->i_sb->s_dio_done_wq,
				   &dio->complete_work);
		} else {
			dio_complete(dio, dio->iocb->ki_pos, 0, true);
		}
321
	}
L
Linus Torvalds 已提交
322 323 324 325 326 327 328 329 330
}

/*
 * 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.
 */
331
static void dio_bio_end_io(struct bio *bio, int error)
L
Linus Torvalds 已提交
332 333 334 335 336 337 338
{
	struct dio *dio = bio->bi_private;
	unsigned long flags;

	spin_lock_irqsave(&dio->bio_lock, flags);
	bio->bi_private = dio->bio_list;
	dio->bio_list = bio;
Z
Zach Brown 已提交
339
	if (--dio->refcount == 1 && dio->waiter)
L
Linus Torvalds 已提交
340 341 342 343
		wake_up_process(dio->waiter);
	spin_unlock_irqrestore(&dio->bio_lock, flags);
}

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
/**
 * 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);

364
static inline void
365 366 367
dio_bio_alloc(struct dio *dio, struct dio_submit *sdio,
	      struct block_device *bdev,
	      sector_t first_sector, int nr_vecs)
L
Linus Torvalds 已提交
368 369 370
{
	struct bio *bio;

371 372 373 374
	/*
	 * bio_alloc() is guaranteed to return a bio when called with
	 * __GFP_WAIT and we request a valid number of vectors.
	 */
L
Linus Torvalds 已提交
375 376 377
	bio = bio_alloc(GFP_KERNEL, nr_vecs);

	bio->bi_bdev = bdev;
378
	bio->bi_iter.bi_sector = first_sector;
L
Linus Torvalds 已提交
379 380 381 382 383
	if (dio->is_async)
		bio->bi_end_io = dio_bio_end_aio;
	else
		bio->bi_end_io = dio_bio_end_io;

384 385
	sdio->bio = bio;
	sdio->logical_offset_in_bio = sdio->cur_page_fs_offset;
L
Linus Torvalds 已提交
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().
392 393
 *
 * bios hold a dio reference between submit_bio and ->end_io.
L
Linus Torvalds 已提交
394
 */
395
static inline void dio_bio_submit(struct dio *dio, struct dio_submit *sdio)
L
Linus Torvalds 已提交
396
{
397
	struct bio *bio = sdio->bio;
Z
Zach Brown 已提交
398
	unsigned long flags;
L
Linus Torvalds 已提交
399 400

	bio->bi_private = dio;
Z
Zach Brown 已提交
401 402 403 404 405

	spin_lock_irqsave(&dio->bio_lock, flags);
	dio->refcount++;
	spin_unlock_irqrestore(&dio->bio_lock, flags);

L
Linus Torvalds 已提交
406 407
	if (dio->is_async && dio->rw == READ)
		bio_set_pages_dirty(bio);
Z
Zach Brown 已提交
408

409 410 411
	if (sdio->submit_io)
		sdio->submit_io(dio->rw, bio, dio->inode,
			       sdio->logical_offset_in_bio);
412 413
	else
		submit_bio(dio->rw, bio);
L
Linus Torvalds 已提交
414

415 416 417
	sdio->bio = NULL;
	sdio->boundary = 0;
	sdio->logical_offset_in_bio = 0;
L
Linus Torvalds 已提交
418 419 420 421 422
}

/*
 * Release any resources in case of a failure
 */
423
static inline void dio_cleanup(struct dio *dio, struct dio_submit *sdio)
L
Linus Torvalds 已提交
424
{
425 426
	while (dio_pages_present(sdio))
		page_cache_release(dio_get_page(dio, sdio));
L
Linus Torvalds 已提交
427 428 429
}

/*
430 431 432 433
 * 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.
L
Linus Torvalds 已提交
434 435 436 437
 */
static struct bio *dio_await_one(struct dio *dio)
{
	unsigned long flags;
438
	struct bio *bio = NULL;
L
Linus Torvalds 已提交
439 440

	spin_lock_irqsave(&dio->bio_lock, flags);
Z
Zach Brown 已提交
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455

	/*
	 * 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;
L
Linus Torvalds 已提交
456
	}
457 458 459 460
	if (dio->bio_list) {
		bio = dio->bio_list;
		dio->bio_list = bio->bi_private;
	}
L
Linus Torvalds 已提交
461 462 463 464 465 466 467 468 469 470
	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);
471 472
	struct bio_vec *bvec;
	unsigned i;
L
Linus Torvalds 已提交
473 474

	if (!uptodate)
475
		dio->io_error = -EIO;
L
Linus Torvalds 已提交
476 477 478 479

	if (dio->is_async && dio->rw == READ) {
		bio_check_pages_dirty(bio);	/* transfers ownership */
	} else {
480 481
		bio_for_each_segment_all(bvec, bio, i) {
			struct page *page = bvec->bv_page;
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489 490 491 492

			if (dio->rw == READ && !PageCompound(page))
				set_page_dirty_lock(page);
			page_cache_release(page);
		}
		bio_put(bio);
	}
	return uptodate ? 0 : -EIO;
}

/*
493 494 495
 * 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
496
 * errors are propagated through dio->io_error and should be propagated via
497
 * dio_complete().
L
Linus Torvalds 已提交
498
 */
499
static void dio_await_completion(struct dio *dio)
L
Linus Torvalds 已提交
500
{
501 502 503 504 505 506
	struct bio *bio;
	do {
		bio = dio_await_one(dio);
		if (bio)
			dio_bio_complete(dio, bio);
	} while (bio);
L
Linus Torvalds 已提交
507 508 509 510 511 512 513 514 515
}

/*
 * 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.
 */
516
static inline int dio_bio_reap(struct dio *dio, struct dio_submit *sdio)
L
Linus Torvalds 已提交
517 518 519
{
	int ret = 0;

520
	if (sdio->reap_counter++ >= 64) {
L
Linus Torvalds 已提交
521 522 523 524 525 526 527 528 529 530 531 532 533
		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;
		}
534
		sdio->reap_counter = 0;
L
Linus Torvalds 已提交
535 536 537 538
	}
	return ret;
}

539 540 541 542 543 544 545 546
/*
 * Create workqueue for deferred direct IO completions. We allocate the
 * workqueue when it's first needed. This avoids creating workqueue for
 * filesystems that don't need it and also allows us to create the workqueue
 * late enough so the we can include s_id in the name of the workqueue.
 */
static int sb_init_dio_done_wq(struct super_block *sb)
{
547
	struct workqueue_struct *old;
548 549 550 551 552 553 554 555
	struct workqueue_struct *wq = alloc_workqueue("dio/%s",
						      WQ_MEM_RECLAIM, 0,
						      sb->s_id);
	if (!wq)
		return -ENOMEM;
	/*
	 * This has to be atomic as more DIOs can race to create the workqueue
	 */
556
	old = cmpxchg(&sb->s_dio_done_wq, NULL, wq);
557
	/* Someone created workqueue before us? Free ours... */
558
	if (old)
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
		destroy_workqueue(wq);
	return 0;
}

static int dio_set_defer_completion(struct dio *dio)
{
	struct super_block *sb = dio->inode->i_sb;

	if (dio->defer_completion)
		return 0;
	dio->defer_completion = true;
	if (!sb->s_dio_done_wq)
		return sb_init_dio_done_wq(sb);
	return 0;
}

L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
578 579 580 581 582
 * 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.
 *
583
 * get_block() is passed the number of i_blkbits-sized blocks which direct_io
L
Linus Torvalds 已提交
584 585 586 587 588 589 590 591 592 593 594 595
 * 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
596
 * block at a time - it will repeatedly call get_block() as it walks the hole.
L
Linus Torvalds 已提交
597
 */
A
Andi Kleen 已提交
598 599
static int get_more_blocks(struct dio *dio, struct dio_submit *sdio,
			   struct buffer_head *map_bh)
L
Linus Torvalds 已提交
600 601 602
{
	int ret;
	sector_t fs_startblk;	/* Into file, in filesystem-sized blocks */
603
	sector_t fs_endblk;	/* Into file, in filesystem-sized blocks */
L
Linus Torvalds 已提交
604 605
	unsigned long fs_count;	/* Number of filesystem-sized blocks */
	int create;
606
	unsigned int i_blkbits = sdio->blkbits + sdio->blkfactor;
L
Linus Torvalds 已提交
607 608 609 610 611 612 613

	/*
	 * 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) {
614 615
		BUG_ON(sdio->block_in_file >= sdio->final_block_in_request);
		fs_startblk = sdio->block_in_file >> sdio->blkfactor;
616 617 618
		fs_endblk = (sdio->final_block_in_request - 1) >>
					sdio->blkfactor;
		fs_count = fs_endblk - fs_startblk + 1;
L
Linus Torvalds 已提交
619

620
		map_bh->b_state = 0;
621
		map_bh->b_size = fs_count << i_blkbits;
622

623 624 625 626 627 628 629 630 631 632 633
		/*
		 * 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.
		 */
J
Jens Axboe 已提交
634
		create = dio->rw & WRITE;
635
		if (dio->flags & DIO_SKIP_HOLES) {
636 637
			if (sdio->block_in_file < (i_size_read(dio->inode) >>
							sdio->blkbits))
L
Linus Torvalds 已提交
638 639
				create = 0;
		}
640

641
		ret = (*sdio->get_block)(dio->inode, fs_startblk,
L
Linus Torvalds 已提交
642
						map_bh, create);
A
Andi Kleen 已提交
643 644 645

		/* Store for completion */
		dio->private = map_bh->b_private;
646 647 648

		if (ret == 0 && buffer_defer_completion(map_bh))
			ret = dio_set_defer_completion(dio);
L
Linus Torvalds 已提交
649 650 651 652 653 654 655
	}
	return ret;
}

/*
 * There is no bio.  Make one now.
 */
656 657
static inline int dio_new_bio(struct dio *dio, struct dio_submit *sdio,
		sector_t start_sector, struct buffer_head *map_bh)
L
Linus Torvalds 已提交
658 659 660 661
{
	sector_t sector;
	int ret, nr_pages;

662
	ret = dio_bio_reap(dio, sdio);
L
Linus Torvalds 已提交
663 664
	if (ret)
		goto out;
665
	sector = start_sector << (sdio->blkbits - 9);
A
Andi Kleen 已提交
666
	nr_pages = min(sdio->pages_in_io, bio_get_nr_vecs(map_bh->b_bdev));
L
Linus Torvalds 已提交
667
	BUG_ON(nr_pages <= 0);
A
Andi Kleen 已提交
668
	dio_bio_alloc(dio, sdio, map_bh->b_bdev, sector, nr_pages);
669
	sdio->boundary = 0;
L
Linus Torvalds 已提交
670 671 672 673 674 675 676 677 678 679 680
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.
 */
681
static inline int dio_bio_add_page(struct dio_submit *sdio)
L
Linus Torvalds 已提交
682 683 684
{
	int ret;

685 686 687
	ret = bio_add_page(sdio->bio, sdio->cur_page,
			sdio->cur_page_len, sdio->cur_page_offset);
	if (ret == sdio->cur_page_len) {
L
Linus Torvalds 已提交
688 689 690
		/*
		 * Decrement count only, if we are done with this page
		 */
691 692 693 694 695
		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);
L
Linus Torvalds 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
		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.
 */
713 714
static inline int dio_send_cur_page(struct dio *dio, struct dio_submit *sdio,
		struct buffer_head *map_bh)
L
Linus Torvalds 已提交
715 716 717
{
	int ret = 0;

718 719 720
	if (sdio->bio) {
		loff_t cur_offset = sdio->cur_page_fs_offset;
		loff_t bio_next_offset = sdio->logical_offset_in_bio +
721
			sdio->bio->bi_iter.bi_size;
722

L
Linus Torvalds 已提交
723
		/*
724 725
		 * See whether this new request is contiguous with the old.
		 *
N
Namhyung Kim 已提交
726 727
		 * Btrfs cannot handle having logically non-contiguous requests
		 * submitted.  For example if you have
728 729
		 *
		 * Logical:  [0-4095][HOLE][8192-12287]
N
Namhyung Kim 已提交
730
		 * Physical: [0-4095]      [4096-8191]
731 732 733 734 735
		 *
		 * 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.
L
Linus Torvalds 已提交
736
		 */
737
		if (sdio->final_block_in_bio != sdio->cur_page_block ||
738
		    cur_offset != bio_next_offset)
739
			dio_bio_submit(dio, sdio);
L
Linus Torvalds 已提交
740 741
	}

742
	if (sdio->bio == NULL) {
A
Andi Kleen 已提交
743
		ret = dio_new_bio(dio, sdio, sdio->cur_page_block, map_bh);
L
Linus Torvalds 已提交
744 745 746 747
		if (ret)
			goto out;
	}

748 749
	if (dio_bio_add_page(sdio) != 0) {
		dio_bio_submit(dio, sdio);
A
Andi Kleen 已提交
750
		ret = dio_new_bio(dio, sdio, sdio->cur_page_block, map_bh);
L
Linus Torvalds 已提交
751
		if (ret == 0) {
752
			ret = dio_bio_add_page(sdio);
L
Linus Torvalds 已提交
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
			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.
 */
777
static inline int
778
submit_page_section(struct dio *dio, struct dio_submit *sdio, struct page *page,
A
Andi Kleen 已提交
779 780
		    unsigned offset, unsigned len, sector_t blocknr,
		    struct buffer_head *map_bh)
L
Linus Torvalds 已提交
781 782 783
{
	int ret = 0;

A
Andrew Morton 已提交
784 785 786 787 788 789 790
	if (dio->rw & WRITE) {
		/*
		 * Read accounting is performed in submit_bio()
		 */
		task_io_account_write(len);
	}

L
Linus Torvalds 已提交
791 792 793
	/*
	 * Can we just grow the current page's presence in the dio?
	 */
794 795 796 797 798
	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;
L
Linus Torvalds 已提交
799 800 801 802 803 804
		goto out;
	}

	/*
	 * If there's a deferred page already there then send it.
	 */
805
	if (sdio->cur_page) {
A
Andi Kleen 已提交
806
		ret = dio_send_cur_page(dio, sdio, map_bh);
807 808
		page_cache_release(sdio->cur_page);
		sdio->cur_page = NULL;
L
Linus Torvalds 已提交
809
		if (ret)
810
			return ret;
L
Linus Torvalds 已提交
811 812 813
	}

	page_cache_get(page);		/* It is in dio */
814 815 816 817 818
	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;
L
Linus Torvalds 已提交
819
out:
820 821 822 823 824 825 826 827 828 829
	/*
	 * If sdio->boundary then we want to schedule the IO now to
	 * avoid metadata seeks.
	 */
	if (sdio->boundary) {
		ret = dio_send_cur_page(dio, sdio, map_bh);
		dio_bio_submit(dio, sdio);
		page_cache_release(sdio->cur_page);
		sdio->cur_page = NULL;
	}
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837
	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
 */
A
Andi Kleen 已提交
838
static void clean_blockdev_aliases(struct dio *dio, struct buffer_head *map_bh)
L
Linus Torvalds 已提交
839 840 841 842
{
	unsigned i;
	unsigned nblocks;

A
Andi Kleen 已提交
843
	nblocks = map_bh->b_size >> dio->inode->i_blkbits;
L
Linus Torvalds 已提交
844 845

	for (i = 0; i < nblocks; i++) {
A
Andi Kleen 已提交
846 847
		unmap_underlying_metadata(map_bh->b_bdev,
					  map_bh->b_blocknr + i);
L
Linus Torvalds 已提交
848 849 850 851 852 853 854 855 856 857 858 859
	}
}

/*
 * 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.
 */
860 861
static inline void dio_zero_block(struct dio *dio, struct dio_submit *sdio,
		int end, struct buffer_head *map_bh)
L
Linus Torvalds 已提交
862 863 864 865 866 867
{
	unsigned dio_blocks_per_fs_block;
	unsigned this_chunk_blocks;	/* In dio_blocks */
	unsigned this_chunk_bytes;
	struct page *page;

868
	sdio->start_zero_done = 1;
A
Andi Kleen 已提交
869
	if (!sdio->blkfactor || !buffer_new(map_bh))
L
Linus Torvalds 已提交
870 871
		return;

872 873
	dio_blocks_per_fs_block = 1 << sdio->blkfactor;
	this_chunk_blocks = sdio->block_in_file & (dio_blocks_per_fs_block - 1);
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881 882 883 884

	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;

885
	this_chunk_bytes = this_chunk_blocks << sdio->blkbits;
L
Linus Torvalds 已提交
886

N
Nick Piggin 已提交
887
	page = ZERO_PAGE(0);
888
	if (submit_page_section(dio, sdio, page, 0, this_chunk_bytes,
A
Andi Kleen 已提交
889
				sdio->next_block_for_io, map_bh))
L
Linus Torvalds 已提交
890 891
		return;

892
	sdio->next_block_for_io += this_chunk_blocks;
L
Linus Torvalds 已提交
893 894 895 896 897 898 899 900 901 902 903
}

/*
 * 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.
 *
904
 * So what we do is to permit the ->get_block function to populate bh.b_size
L
Linus Torvalds 已提交
905 906 907
 * 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
908
 * it should set b_size to PAGE_SIZE or more inside get_block().  This gives
L
Linus Torvalds 已提交
909 910
 * fine alignment but still allows this function to work in PAGE_SIZE units.
 */
A
Andi Kleen 已提交
911 912
static int do_direct_IO(struct dio *dio, struct dio_submit *sdio,
			struct buffer_head *map_bh)
L
Linus Torvalds 已提交
913
{
914
	const unsigned blkbits = sdio->blkbits;
L
Linus Torvalds 已提交
915 916 917 918 919 920
	const unsigned blocks_per_page = PAGE_SIZE >> blkbits;
	struct page *page;
	unsigned block_in_page;
	int ret = 0;

	/* The I/O can start at any block offset within the first page */
921
	block_in_page = sdio->first_block_in_page;
L
Linus Torvalds 已提交
922

923 924
	while (sdio->block_in_file < sdio->final_block_in_request) {
		page = dio_get_page(dio, sdio);
L
Linus Torvalds 已提交
925 926 927 928 929 930 931 932 933 934 935
		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;

936
			if (sdio->blocks_available == 0) {
L
Linus Torvalds 已提交
937 938 939 940 941 942
				/*
				 * Need to go and map some more disk
				 */
				unsigned long blkmask;
				unsigned long dio_remainder;

A
Andi Kleen 已提交
943
				ret = get_more_blocks(dio, sdio, map_bh);
L
Linus Torvalds 已提交
944 945 946 947 948 949 950
				if (ret) {
					page_cache_release(page);
					goto out;
				}
				if (!buffer_mapped(map_bh))
					goto do_holes;

951 952 953 954
				sdio->blocks_available =
						map_bh->b_size >> sdio->blkbits;
				sdio->next_block_for_io =
					map_bh->b_blocknr << sdio->blkfactor;
L
Linus Torvalds 已提交
955
				if (buffer_new(map_bh))
A
Andi Kleen 已提交
956
					clean_blockdev_aliases(dio, map_bh);
L
Linus Torvalds 已提交
957

958
				if (!sdio->blkfactor)
L
Linus Torvalds 已提交
959 960
					goto do_holes;

961 962
				blkmask = (1 << sdio->blkfactor) - 1;
				dio_remainder = (sdio->block_in_file & blkmask);
L
Linus Torvalds 已提交
963 964 965 966 967 968 969 970 971 972 973 974 975

				/*
				 * 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))
976 977
					sdio->next_block_for_io += dio_remainder;
				sdio->blocks_available -= dio_remainder;
L
Linus Torvalds 已提交
978 979 980 981
			}
do_holes:
			/* Handle holes */
			if (!buffer_mapped(map_bh)) {
982
				loff_t i_size_aligned;
L
Linus Torvalds 已提交
983 984

				/* AKPM: eargh, -ENOTBLK is a hack */
J
Jens Axboe 已提交
985
				if (dio->rw & WRITE) {
L
Linus Torvalds 已提交
986 987 988 989
					page_cache_release(page);
					return -ENOTBLK;
				}

990 991 992 993 994 995
				/*
				 * 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);
996
				if (sdio->block_in_file >=
997
						i_size_aligned >> blkbits) {
L
Linus Torvalds 已提交
998 999 1000 1001
					/* We hit eof */
					page_cache_release(page);
					goto out;
				}
1002 1003
				zero_user(page, block_in_page << blkbits,
						1 << blkbits);
1004
				sdio->block_in_file++;
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010 1011 1012 1013
				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.
			 */
1014
			if (unlikely(sdio->blkfactor && !sdio->start_zero_done))
A
Andi Kleen 已提交
1015
				dio_zero_block(dio, sdio, 0, map_bh);
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020

			/*
			 * Work out, in this_chunk_blocks, how much disk we
			 * can add to this page
			 */
1021
			this_chunk_blocks = sdio->blocks_available;
L
Linus Torvalds 已提交
1022 1023 1024
			u = (PAGE_SIZE - offset_in_page) >> blkbits;
			if (this_chunk_blocks > u)
				this_chunk_blocks = u;
1025
			u = sdio->final_block_in_request - sdio->block_in_file;
L
Linus Torvalds 已提交
1026 1027 1028 1029 1030
			if (this_chunk_blocks > u)
				this_chunk_blocks = u;
			this_chunk_bytes = this_chunk_blocks << blkbits;
			BUG_ON(this_chunk_bytes == 0);

1031 1032
			if (this_chunk_blocks == sdio->blocks_available)
				sdio->boundary = buffer_boundary(map_bh);
1033 1034 1035
			ret = submit_page_section(dio, sdio, page,
						  offset_in_page,
						  this_chunk_bytes,
A
Andi Kleen 已提交
1036 1037
						  sdio->next_block_for_io,
						  map_bh);
L
Linus Torvalds 已提交
1038 1039 1040 1041
			if (ret) {
				page_cache_release(page);
				goto out;
			}
1042
			sdio->next_block_for_io += this_chunk_blocks;
L
Linus Torvalds 已提交
1043

1044
			sdio->block_in_file += this_chunk_blocks;
L
Linus Torvalds 已提交
1045
			block_in_page += this_chunk_blocks;
1046
			sdio->blocks_available -= this_chunk_blocks;
L
Linus Torvalds 已提交
1047
next_block:
1048 1049
			BUG_ON(sdio->block_in_file > sdio->final_block_in_request);
			if (sdio->block_in_file == sdio->final_block_in_request)
L
Linus Torvalds 已提交
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
				break;
		}

		/* Drop the ref which was taken in get_user_pages() */
		page_cache_release(page);
		block_in_page = 0;
	}
out:
	return ret;
}

1061
static inline int drop_refcount(struct dio *dio)
L
Linus Torvalds 已提交
1062
{
1063
	int ret2;
Z
Zach Brown 已提交
1064
	unsigned long flags;
L
Linus Torvalds 已提交
1065

1066 1067
	/*
	 * Sync will always be dropping the final ref and completing the
Z
Zach Brown 已提交
1068 1069 1070 1071 1072 1073 1074 1075
	 * 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.
1076
	 */
Z
Zach Brown 已提交
1077 1078 1079
	spin_lock_irqsave(&dio->bio_lock, flags);
	ret2 = --dio->refcount;
	spin_unlock_irqrestore(&dio->bio_lock, flags);
1080
	return ret2;
L
Linus Torvalds 已提交
1081 1082
}

1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
/*
 * 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.
 *  - 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.
1095 1096 1097 1098 1099 1100 1101
 *
 * 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.
1102 1103 1104 1105 1106
 *
 * 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.
1107
 */
1108 1109
static inline ssize_t
do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
1110 1111
	struct block_device *bdev, struct iov_iter *iter, loff_t offset, 
	get_block_t get_block, dio_iodone_t end_io,
1112
	dio_submit_t submit_io,	int flags)
L
Linus Torvalds 已提交
1113 1114 1115 1116
{
	int seg;
	size_t size;
	unsigned long addr;
1117 1118
	unsigned i_blkbits = ACCESS_ONCE(inode->i_blkbits);
	unsigned blkbits = i_blkbits;
L
Linus Torvalds 已提交
1119 1120 1121 1122
	unsigned blocksize_mask = (1 << blkbits) - 1;
	ssize_t retval = -EINVAL;
	loff_t end = offset;
	struct dio *dio;
1123
	struct dio_submit sdio = { 0, };
1124 1125 1126
	unsigned long user_addr;
	size_t bytes;
	struct buffer_head map_bh = { 0, };
1127
	struct blk_plug plug;
L
Linus Torvalds 已提交
1128 1129

	if (rw & WRITE)
J
Jens Axboe 已提交
1130
		rw = WRITE_ODIRECT;
L
Linus Torvalds 已提交
1131

1132 1133 1134 1135
	/*
	 * Avoid references to bdev if not absolutely needed to give
	 * the early prefetch in the caller enough time.
	 */
L
Linus Torvalds 已提交
1136 1137 1138

	if (offset & blocksize_mask) {
		if (bdev)
1139
			blkbits = blksize_bits(bdev_logical_block_size(bdev));
L
Linus Torvalds 已提交
1140 1141 1142 1143 1144 1145
		blocksize_mask = (1 << blkbits) - 1;
		if (offset & blocksize_mask)
			goto out;
	}

	/* Check the memory alignment.  Blocks cannot straddle pages */
1146 1147 1148
	for (seg = 0; seg < iter->nr_segs; seg++) {
		addr = (unsigned long)iter->iov[seg].iov_base;
		size = iter->iov[seg].iov_len;
L
Linus Torvalds 已提交
1149
		end += size;
1150 1151
		if (unlikely((addr & blocksize_mask) ||
			     (size & blocksize_mask))) {
L
Linus Torvalds 已提交
1152
			if (bdev)
1153 1154
				blkbits = blksize_bits(
					 bdev_logical_block_size(bdev));
L
Linus Torvalds 已提交
1155
			blocksize_mask = (1 << blkbits) - 1;
1156
			if ((addr & blocksize_mask) || (size & blocksize_mask))
L
Linus Torvalds 已提交
1157 1158 1159 1160
				goto out;
		}
	}

1161 1162 1163 1164
	/* watch out for a 0 len io from a tricksy fs */
	if (rw == READ && end == offset)
		return 0;

1165
	dio = kmem_cache_alloc(dio_cache, GFP_KERNEL);
L
Linus Torvalds 已提交
1166 1167 1168
	retval = -ENOMEM;
	if (!dio)
		goto out;
1169 1170 1171 1172 1173 1174
	/*
	 * 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));
L
Linus Torvalds 已提交
1175

1176 1177
	dio->flags = flags;
	if (dio->flags & DIO_LOCKING) {
1178
		if (rw == READ) {
1179 1180
			struct address_space *mapping =
					iocb->ki_filp->f_mapping;
L
Linus Torvalds 已提交
1181

1182 1183
			/* will be released by direct_io_worker */
			mutex_lock(&inode->i_mutex);
L
Linus Torvalds 已提交
1184 1185 1186 1187

			retval = filemap_write_and_wait_range(mapping, offset,
							      end - 1);
			if (retval) {
1188
				mutex_unlock(&inode->i_mutex);
1189
				kmem_cache_free(dio_cache, dio);
L
Linus Torvalds 已提交
1190 1191 1192 1193 1194 1195
				goto out;
			}
		}
	}

	/*
1196 1197 1198 1199
	 * For file extending writes updating i_size before data writeouts
	 * complete can expose uninitialized blocks in dumb filesystems.
	 * In that case we need to wait for I/O completion even if asked
	 * for an asynchronous write.
L
Linus Torvalds 已提交
1200
	 */
1201 1202 1203 1204 1205 1206 1207 1208
	if (is_sync_kiocb(iocb))
		dio->is_async = false;
	else if (!(dio->flags & DIO_ASYNC_EXTEND) &&
            (rw & WRITE) && end > i_size_read(inode))
		dio->is_async = false;
	else
		dio->is_async = true;

1209 1210
	dio->inode = inode;
	dio->rw = rw;
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

	/*
	 * For AIO O_(D)SYNC writes we need to defer completions to a workqueue
	 * so that we can call ->fsync.
	 */
	if (dio->is_async && (rw & WRITE) &&
	    ((iocb->ki_filp->f_flags & O_DSYNC) ||
	     IS_SYNC(iocb->ki_filp->f_mapping->host))) {
		retval = dio_set_defer_completion(dio);
		if (retval) {
			/*
			 * We grab i_mutex only for reads so we don't have
			 * to release it here
			 */
			kmem_cache_free(dio_cache, dio);
			goto out;
		}
	}

	/*
	 * Will be decremented at I/O completion time.
	 */
	atomic_inc(&inode->i_dio_count);

	retval = 0;
1236
	sdio.blkbits = blkbits;
1237
	sdio.blkfactor = i_blkbits - blkbits;
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
	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;

1259 1260
	for (seg = 0; seg < iter->nr_segs; seg++) {
		user_addr = (unsigned long)iter->iov[seg].iov_base;
1261
		sdio.pages_in_io +=
1262
			((user_addr + iter->iov[seg].iov_len + PAGE_SIZE-1) /
1263 1264 1265
				PAGE_SIZE - user_addr / PAGE_SIZE);
	}

1266 1267
	blk_start_plug(&plug);

1268 1269 1270
	for (seg = 0; seg < iter->nr_segs; seg++) {
		user_addr = (unsigned long)iter->iov[seg].iov_base;
		sdio.size += bytes = iter->iov[seg].iov_len;
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290

		/* 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);

1291
		dio->result += iter->iov[seg].iov_len -
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
			((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);

1326 1327
	blk_finish_plug(&plug);

1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
	/*
	 * 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 &&
1351
	    ((rw == READ) || (dio->result == sdio.size)))
1352 1353 1354 1355 1356 1357 1358 1359 1360
		retval = -EIOCBQUEUED;

	if (retval != -EIOCBQUEUED)
		dio_await_completion(dio);

	if (drop_refcount(dio) == 0) {
		retval = dio_complete(dio, offset, retval, false);
	} else
		BUG_ON(retval != -EIOCBQUEUED);
L
Linus Torvalds 已提交
1361

1362 1363 1364
out:
	return retval;
}
1365 1366 1367

ssize_t
__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
1368 1369
	struct block_device *bdev, struct iov_iter *iter, loff_t offset,
	get_block_t get_block, dio_iodone_t end_io,
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
	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);

1384 1385
	return do_blockdev_direct_IO(rw, iocb, inode, bdev, iter, offset,
				     get_block, end_io, submit_io, flags);
1386 1387
}

L
Linus Torvalds 已提交
1388
EXPORT_SYMBOL(__blockdev_direct_IO);
1389 1390 1391 1392 1393 1394 1395

static __init int dio_init(void)
{
	dio_cache = KMEM_CACHE(dio, SLAB_PANIC);
	return 0;
}
module_init(dio_init)