2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* fs/direct-io.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2002, Linus Torvalds.
|
|
|
|
*
|
|
|
|
* O_DIRECT
|
|
|
|
*
|
2008-10-16 12:01:59 +07:00
|
|
|
* 04Jul2002 Andrew Morton
|
2005-04-17 05:20:36 +07:00
|
|
|
* Initial version
|
|
|
|
* 11Sep2002 janetinc@us.ibm.com
|
|
|
|
* added readv/writev support.
|
2008-10-16 12:01:59 +07:00
|
|
|
* 29Oct2002 Andrew Morton
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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>
|
2006-12-10 17:19:47 +07:00
|
|
|
#include <linux/task_io_accounting_ops.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#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>
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* How many user pages to map in one call to get_user_pages(). This determines
|
|
|
|
* the size of a structure on the stack.
|
|
|
|
*/
|
|
|
|
#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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct dio {
|
|
|
|
/* BIO submission state */
|
|
|
|
struct bio *bio; /* bio under assembly */
|
|
|
|
struct inode *inode;
|
|
|
|
int rw;
|
2005-04-17 05:25:50 +07:00
|
|
|
loff_t i_size; /* i_size when submitted */
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
int flags; /* doesn't change */
|
2005-04-17 05:20:36 +07:00
|
|
|
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 */
|
|
|
|
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 */
|
|
|
|
int reap_counter; /* rate limit reaping */
|
2006-03-26 16:38:02 +07:00
|
|
|
get_block_t *get_block; /* block mapping function */
|
2005-04-17 05:20:36 +07:00
|
|
|
dio_iodone_t *end_io; /* IO completion function */
|
2010-05-23 22:00:55 +07:00
|
|
|
dio_submit_t *submit_io; /* IO submition function */
|
|
|
|
loff_t logical_offset_in_bio; /* current first logical block in bio */
|
2005-04-17 05:20:36 +07:00
|
|
|
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 */
|
2006-03-26 16:38:02 +07:00
|
|
|
struct buffer_head map_bh; /* last get_block() result */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 */
|
2010-05-23 22:00:55 +07:00
|
|
|
loff_t cur_page_fs_offset; /* Offset in file */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-12-16 07:47:49 +07:00
|
|
|
/* BIO completion state */
|
|
|
|
spinlock_t bio_lock; /* protects BIO fields below */
|
|
|
|
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 */
|
|
|
|
int is_async; /* is IO async ? */
|
|
|
|
int io_error; /* IO error in completion path */
|
|
|
|
ssize_t result; /* IO result */
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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 */
|
|
|
|
int page_errors; /* errno from get_user_pages() */
|
|
|
|
|
2009-12-16 07:47:49 +07:00
|
|
|
/*
|
|
|
|
* pages[] (and any fields placed after it) are not zeroed out at
|
|
|
|
* allocation time. Don't add new fields after pages[] unless you
|
|
|
|
* wish that they not be zeroed.
|
|
|
|
*/
|
|
|
|
struct page *pages[DIO_PAGES]; /* page buffer */
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* How many pages are in the queue?
|
|
|
|
*/
|
|
|
|
static inline unsigned dio_pages_present(struct dio *dio)
|
|
|
|
{
|
|
|
|
return dio->tail - dio->head;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Go grab and pin some userspace pages. Typically we'll get 64 at a time.
|
|
|
|
*/
|
|
|
|
static int dio_refill_pages(struct dio *dio)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int nr_pages;
|
|
|
|
|
|
|
|
nr_pages = min(dio->total_pages - dio->curr_page, DIO_PAGES);
|
2008-07-26 09:45:25 +07:00
|
|
|
ret = get_user_pages_fast(
|
2005-04-17 05:20:36 +07:00
|
|
|
dio->curr_user_address, /* Where from? */
|
|
|
|
nr_pages, /* How many pages? */
|
|
|
|
dio->rw == READ, /* Write to memory? */
|
2008-07-26 09:45:25 +07:00
|
|
|
&dio->pages[0]); /* Put results here */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-13 13:26:10 +07:00
|
|
|
if (ret < 0 && dio->blocks_available && (dio->rw & WRITE)) {
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 15:24:40 +07:00
|
|
|
struct page *page = ZERO_PAGE(0);
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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;
|
2005-10-30 08:16:12 +07:00
|
|
|
page_cache_get(page);
|
|
|
|
dio->pages[0] = page;
|
2005-04-17 05:20:36 +07:00
|
|
|
dio->head = 0;
|
|
|
|
dio->tail = 1;
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret >= 0) {
|
|
|
|
dio->curr_user_address += ret * PAGE_SIZE;
|
|
|
|
dio->curr_page += ret;
|
|
|
|
dio->head = 0;
|
|
|
|
dio->tail = ret;
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static struct page *dio_get_page(struct dio *dio)
|
|
|
|
{
|
|
|
|
if (dio_pages_present(dio) == 0) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = dio_refill_pages(dio);
|
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
BUG_ON(dio_pages_present(dio) == 0);
|
|
|
|
}
|
|
|
|
return dio->pages[dio->head++];
|
|
|
|
}
|
|
|
|
|
2006-12-10 17:20:54 +07:00
|
|
|
/**
|
|
|
|
* dio_complete() - called when all DIO BIO I/O has been completed
|
|
|
|
* @offset: the byte offset in the file of the completed operation
|
|
|
|
*
|
|
|
|
* This releases locks as dictated by the locking type, lets interested parties
|
|
|
|
* know that a DIO operation has completed, and calculates the resulting return
|
|
|
|
* code for the operation.
|
|
|
|
*
|
|
|
|
* It lets the filesystem know if it registered an interest earlier via
|
|
|
|
* get_block. Pass the private field of the map buffer_head so that
|
|
|
|
* filesystems can use it to hold additional state between get_block calls and
|
|
|
|
* dio_complete.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2010-10-27 04:22:28 +07:00
|
|
|
static ssize_t dio_complete(struct dio *dio, loff_t offset, ssize_t ret, bool is_async)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-12-10 17:20:54 +07:00
|
|
|
ssize_t transferred = 0;
|
|
|
|
|
2006-12-10 17:21:05 +07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2006-12-10 17:20:54 +07:00
|
|
|
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;
|
|
|
|
|
2010-07-19 04:17:09 +07:00
|
|
|
if (dio->end_io && dio->result) {
|
|
|
|
dio->end_io(dio->iocb, offset, transferred,
|
|
|
|
dio->map_bh.b_private, ret, is_async);
|
|
|
|
} else if (is_async) {
|
|
|
|
aio_complete(dio->iocb, ret, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dio->flags & DIO_LOCKING)
|
|
|
|
/* lockdep: non-owner release */
|
|
|
|
up_read_non_owner(&dio->inode->i_alloc_sem);
|
|
|
|
|
2006-12-10 17:20:54 +07:00
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int dio_bio_complete(struct dio *dio, struct bio *bio);
|
|
|
|
/*
|
|
|
|
* Asynchronous IO callback.
|
|
|
|
*/
|
2007-09-27 17:47:43 +07:00
|
|
|
static void dio_bio_end_aio(struct bio *bio, int error)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct dio *dio = bio->bi_private;
|
2006-12-10 17:21:07 +07:00
|
|
|
unsigned long remaining;
|
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* cleanup the bio */
|
|
|
|
dio_bio_complete(dio, bio);
|
2006-12-10 17:20:59 +07:00
|
|
|
|
2006-12-10 17:21:07 +07:00
|
|
|
spin_lock_irqsave(&dio->bio_lock, flags);
|
|
|
|
remaining = --dio->refcount;
|
|
|
|
if (remaining == 1 && dio->waiter)
|
2006-12-10 17:21:01 +07:00
|
|
|
wake_up_process(dio->waiter);
|
2006-12-10 17:21:07 +07:00
|
|
|
spin_unlock_irqrestore(&dio->bio_lock, flags);
|
2006-12-10 17:21:01 +07:00
|
|
|
|
2006-12-10 17:21:05 +07:00
|
|
|
if (remaining == 0) {
|
2010-07-19 04:17:09 +07:00
|
|
|
dio_complete(dio, dio->iocb->ki_pos, 0, true);
|
2006-12-10 17:21:05 +07:00
|
|
|
kfree(dio);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2007-09-27 17:47:43 +07:00
|
|
|
static void dio_bio_end_io(struct bio *bio, int error)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
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;
|
2006-12-10 17:21:07 +07:00
|
|
|
if (--dio->refcount == 1 && dio->waiter)
|
2005-04-17 05:20:36 +07:00
|
|
|
wake_up_process(dio->waiter);
|
|
|
|
spin_unlock_irqrestore(&dio->bio_lock, flags);
|
|
|
|
}
|
|
|
|
|
2010-05-23 22:00:55 +07:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int
|
|
|
|
dio_bio_alloc(struct dio *dio, struct block_device *bdev,
|
|
|
|
sector_t first_sector, int nr_vecs)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
bio = bio_alloc(GFP_KERNEL, nr_vecs);
|
|
|
|
|
|
|
|
bio->bi_bdev = bdev;
|
|
|
|
bio->bi_sector = first_sector;
|
|
|
|
if (dio->is_async)
|
|
|
|
bio->bi_end_io = dio_bio_end_aio;
|
|
|
|
else
|
|
|
|
bio->bi_end_io = dio_bio_end_io;
|
|
|
|
|
|
|
|
dio->bio = bio;
|
2010-05-23 22:00:55 +07:00
|
|
|
dio->logical_offset_in_bio = dio->cur_page_fs_offset;
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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().
|
2006-12-10 17:20:59 +07:00
|
|
|
*
|
|
|
|
* bios hold a dio reference between submit_bio and ->end_io.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
static void dio_bio_submit(struct dio *dio)
|
|
|
|
{
|
|
|
|
struct bio *bio = dio->bio;
|
2006-12-10 17:21:07 +07:00
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
bio->bi_private = dio;
|
2006-12-10 17:21:07 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dio->bio_lock, flags);
|
|
|
|
dio->refcount++;
|
|
|
|
spin_unlock_irqrestore(&dio->bio_lock, flags);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dio->is_async && dio->rw == READ)
|
|
|
|
bio_set_pages_dirty(bio);
|
2006-12-10 17:21:07 +07:00
|
|
|
|
2010-05-23 22:00:55 +07:00
|
|
|
if (dio->submit_io)
|
|
|
|
dio->submit_io(dio->rw, bio, dio->inode,
|
|
|
|
dio->logical_offset_in_bio);
|
|
|
|
else
|
|
|
|
submit_bio(dio->rw, bio);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
dio->bio = NULL;
|
|
|
|
dio->boundary = 0;
|
2010-05-23 22:00:55 +07:00
|
|
|
dio->logical_offset_in_bio = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Release any resources in case of a failure
|
|
|
|
*/
|
|
|
|
static void dio_cleanup(struct dio *dio)
|
|
|
|
{
|
|
|
|
while (dio_pages_present(dio))
|
|
|
|
page_cache_release(dio_get_page(dio));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-12-10 17:20:59 +07:00
|
|
|
* 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.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
static struct bio *dio_await_one(struct dio *dio)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2006-12-10 17:20:59 +07:00
|
|
|
struct bio *bio = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dio->bio_lock, flags);
|
2006-12-10 17:21:07 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-12-10 17:20:59 +07:00
|
|
|
if (dio->bio_list) {
|
|
|
|
bio = dio->bio_list;
|
|
|
|
dio->bio_list = bio->bi_private;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&dio->bio_lock, flags);
|
|
|
|
return bio;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process one completed BIO. No locks are held.
|
|
|
|
*/
|
|
|
|
static int dio_bio_complete(struct dio *dio, struct bio *bio)
|
|
|
|
{
|
|
|
|
const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
|
|
|
|
struct bio_vec *bvec = bio->bi_io_vec;
|
|
|
|
int page_no;
|
|
|
|
|
|
|
|
if (!uptodate)
|
2006-03-25 18:08:16 +07:00
|
|
|
dio->io_error = -EIO;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (dio->is_async && dio->rw == READ) {
|
|
|
|
bio_check_pages_dirty(bio); /* transfers ownership */
|
|
|
|
} else {
|
|
|
|
for (page_no = 0; page_no < bio->bi_vcnt; page_no++) {
|
|
|
|
struct page *page = bvec[page_no].bv_page;
|
|
|
|
|
|
|
|
if (dio->rw == READ && !PageCompound(page))
|
|
|
|
set_page_dirty_lock(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
return uptodate ? 0 : -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-12-10 17:20:59 +07:00
|
|
|
* 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
|
2007-05-09 12:14:03 +07:00
|
|
|
* errors are propagated through dio->io_error and should be propagated via
|
2006-12-10 17:20:59 +07:00
|
|
|
* dio_complete().
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-12-10 17:20:54 +07:00
|
|
|
static void dio_await_completion(struct dio *dio)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-12-10 17:20:59 +07:00
|
|
|
struct bio *bio;
|
|
|
|
do {
|
|
|
|
bio = dio_await_one(dio);
|
|
|
|
if (bio)
|
|
|
|
dio_bio_complete(dio, bio);
|
|
|
|
} while (bio);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static int dio_bio_reap(struct dio *dio)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (dio->reap_counter++ >= 64) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
dio->reap_counter = 0;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call into the fs to map some more disk blocks. We record the current number
|
|
|
|
* of available blocks at dio->blocks_available. These are in units of the
|
|
|
|
* 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.
|
|
|
|
*
|
2006-03-26 16:38:02 +07:00
|
|
|
* get_block() is passed the number of i_blkbits-sized blocks which direct_io
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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
|
2006-03-26 16:38:02 +07:00
|
|
|
* block at a time - it will repeatedly call get_block() as it walks the hole.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
static int get_more_blocks(struct dio *dio)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct buffer_head *map_bh = &dio->map_bh;
|
|
|
|
sector_t fs_startblk; /* Into file, in filesystem-sized blocks */
|
|
|
|
unsigned long fs_count; /* Number of filesystem-sized blocks */
|
|
|
|
unsigned long dio_count;/* Number of dio_block-sized blocks */
|
|
|
|
unsigned long blkmask;
|
|
|
|
int create;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there was a memory error and we've overwritten all the
|
|
|
|
* mapped blocks then we can now return that memory error
|
|
|
|
*/
|
|
|
|
ret = dio->page_errors;
|
|
|
|
if (ret == 0) {
|
|
|
|
BUG_ON(dio->block_in_file >= dio->final_block_in_request);
|
|
|
|
fs_startblk = dio->block_in_file >> dio->blkfactor;
|
|
|
|
dio_count = dio->final_block_in_request - dio->block_in_file;
|
|
|
|
fs_count = dio_count >> dio->blkfactor;
|
|
|
|
blkmask = (1 << dio->blkfactor) - 1;
|
|
|
|
if (dio_count & blkmask)
|
|
|
|
fs_count++;
|
|
|
|
|
2006-03-29 06:26:15 +07:00
|
|
|
map_bh->b_state = 0;
|
|
|
|
map_bh->b_size = fs_count << dio->inode->i_blkbits;
|
|
|
|
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2006-06-13 13:26:10 +07:00
|
|
|
create = dio->rw & WRITE;
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
if (dio->flags & DIO_SKIP_HOLES) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dio->block_in_file < (i_size_read(dio->inode) >>
|
|
|
|
dio->blkbits))
|
|
|
|
create = 0;
|
|
|
|
}
|
2006-03-29 06:26:15 +07:00
|
|
|
|
2006-03-26 16:38:02 +07:00
|
|
|
ret = (*dio->get_block)(dio->inode, fs_startblk,
|
2005-04-17 05:20:36 +07:00
|
|
|
map_bh, create);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is no bio. Make one now.
|
|
|
|
*/
|
|
|
|
static int dio_new_bio(struct dio *dio, sector_t start_sector)
|
|
|
|
{
|
|
|
|
sector_t sector;
|
|
|
|
int ret, nr_pages;
|
|
|
|
|
|
|
|
ret = dio_bio_reap(dio);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
sector = start_sector << (dio->blkbits - 9);
|
|
|
|
nr_pages = min(dio->pages_in_io, bio_get_nr_vecs(dio->map_bh.b_bdev));
|
|
|
|
BUG_ON(nr_pages <= 0);
|
|
|
|
ret = dio_bio_alloc(dio, dio->map_bh.b_bdev, sector, nr_pages);
|
|
|
|
dio->boundary = 0;
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static int dio_bio_add_page(struct dio *dio)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = bio_add_page(dio->bio, dio->cur_page,
|
|
|
|
dio->cur_page_len, dio->cur_page_offset);
|
|
|
|
if (ret == dio->cur_page_len) {
|
|
|
|
/*
|
|
|
|
* Decrement count only, if we are done with this page
|
|
|
|
*/
|
|
|
|
if ((dio->cur_page_len + dio->cur_page_offset) == PAGE_SIZE)
|
|
|
|
dio->pages_in_io--;
|
|
|
|
page_cache_get(dio->cur_page);
|
|
|
|
dio->final_block_in_bio = dio->cur_page_block +
|
|
|
|
(dio->cur_page_len >> dio->blkbits);
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static int dio_send_cur_page(struct dio *dio)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (dio->bio) {
|
2010-09-10 06:37:33 +07:00
|
|
|
loff_t cur_offset = dio->cur_page_fs_offset;
|
2010-05-23 22:00:55 +07:00
|
|
|
loff_t bio_next_offset = dio->logical_offset_in_bio +
|
|
|
|
dio->bio->bi_size;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2010-05-23 22:00:55 +07:00
|
|
|
* See whether this new request is contiguous with the old.
|
|
|
|
*
|
|
|
|
* Btrfs cannot handl having logically non-contiguous requests
|
|
|
|
* submitted. For exmple if you have
|
|
|
|
*
|
|
|
|
* Logical: [0-4095][HOLE][8192-12287]
|
|
|
|
* Phyiscal: [0-4095] [4096-8181]
|
|
|
|
*
|
|
|
|
* 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.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2010-05-23 22:00:55 +07:00
|
|
|
if (dio->final_block_in_bio != dio->cur_page_block ||
|
|
|
|
cur_offset != bio_next_offset)
|
2005-04-17 05:20:36 +07:00
|
|
|
dio_bio_submit(dio);
|
|
|
|
/*
|
|
|
|
* Submit now if the underlying fs is about to perform a
|
|
|
|
* metadata read
|
|
|
|
*/
|
2010-09-10 06:37:33 +07:00
|
|
|
else if (dio->boundary)
|
2005-04-17 05:20:36 +07:00
|
|
|
dio_bio_submit(dio);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dio->bio == NULL) {
|
|
|
|
ret = dio_new_bio(dio, dio->cur_page_block);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dio_bio_add_page(dio) != 0) {
|
|
|
|
dio_bio_submit(dio);
|
|
|
|
ret = dio_new_bio(dio, dio->cur_page_block);
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = dio_bio_add_page(dio);
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
submit_page_section(struct dio *dio, struct page *page,
|
|
|
|
unsigned offset, unsigned len, sector_t blocknr)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2006-12-10 17:19:47 +07:00
|
|
|
if (dio->rw & WRITE) {
|
|
|
|
/*
|
|
|
|
* Read accounting is performed in submit_bio()
|
|
|
|
*/
|
|
|
|
task_io_account_write(len);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Can we just grow the current page's presence in the dio?
|
|
|
|
*/
|
|
|
|
if ( (dio->cur_page == page) &&
|
|
|
|
(dio->cur_page_offset + dio->cur_page_len == offset) &&
|
|
|
|
(dio->cur_page_block +
|
|
|
|
(dio->cur_page_len >> dio->blkbits) == blocknr)) {
|
|
|
|
dio->cur_page_len += len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If dio->boundary then we want to schedule the IO now to
|
|
|
|
* avoid metadata seeks.
|
|
|
|
*/
|
|
|
|
if (dio->boundary) {
|
|
|
|
ret = dio_send_cur_page(dio);
|
|
|
|
page_cache_release(dio->cur_page);
|
|
|
|
dio->cur_page = NULL;
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's a deferred page already there then send it.
|
|
|
|
*/
|
|
|
|
if (dio->cur_page) {
|
|
|
|
ret = dio_send_cur_page(dio);
|
|
|
|
page_cache_release(dio->cur_page);
|
|
|
|
dio->cur_page = NULL;
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
page_cache_get(page); /* It is in dio */
|
|
|
|
dio->cur_page = page;
|
|
|
|
dio->cur_page_offset = offset;
|
|
|
|
dio->cur_page_len = len;
|
|
|
|
dio->cur_page_block = blocknr;
|
2010-05-23 22:00:55 +07:00
|
|
|
dio->cur_page_fs_offset = dio->block_in_file << dio->blkbits;
|
2005-04-17 05:20:36 +07:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clean any dirty buffers in the blockdev mapping which alias newly-created
|
|
|
|
* file blocks. Only called for S_ISREG files - blockdevs do not set
|
|
|
|
* buffer_new
|
|
|
|
*/
|
|
|
|
static void clean_blockdev_aliases(struct dio *dio)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
unsigned nblocks;
|
|
|
|
|
|
|
|
nblocks = dio->map_bh.b_size >> dio->inode->i_blkbits;
|
|
|
|
|
|
|
|
for (i = 0; i < nblocks; i++) {
|
|
|
|
unmap_underlying_metadata(dio->map_bh.b_bdev,
|
|
|
|
dio->map_bh.b_blocknr + i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static void dio_zero_block(struct dio *dio, int end)
|
|
|
|
{
|
|
|
|
unsigned dio_blocks_per_fs_block;
|
|
|
|
unsigned this_chunk_blocks; /* In dio_blocks */
|
|
|
|
unsigned this_chunk_bytes;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
dio->start_zero_done = 1;
|
|
|
|
if (!dio->blkfactor || !buffer_new(&dio->map_bh))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dio_blocks_per_fs_block = 1 << dio->blkfactor;
|
|
|
|
this_chunk_blocks = dio->block_in_file & (dio_blocks_per_fs_block - 1);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
this_chunk_bytes = this_chunk_blocks << dio->blkbits;
|
|
|
|
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 15:24:40 +07:00
|
|
|
page = ZERO_PAGE(0);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (submit_page_section(dio, page, 0, this_chunk_bytes,
|
|
|
|
dio->next_block_for_io))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dio->next_block_for_io += this_chunk_blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
2006-03-26 16:38:02 +07:00
|
|
|
* So what we do is to permit the ->get_block function to populate bh.b_size
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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
|
2006-03-26 16:38:02 +07:00
|
|
|
* it should set b_size to PAGE_SIZE or more inside get_block(). This gives
|
2005-04-17 05:20:36 +07:00
|
|
|
* fine alignment but still allows this function to work in PAGE_SIZE units.
|
|
|
|
*/
|
|
|
|
static int do_direct_IO(struct dio *dio)
|
|
|
|
{
|
|
|
|
const unsigned blkbits = dio->blkbits;
|
|
|
|
const unsigned blocks_per_page = PAGE_SIZE >> blkbits;
|
|
|
|
struct page *page;
|
|
|
|
unsigned block_in_page;
|
|
|
|
struct buffer_head *map_bh = &dio->map_bh;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* The I/O can start at any block offset within the first page */
|
|
|
|
block_in_page = dio->first_block_in_page;
|
|
|
|
|
|
|
|
while (dio->block_in_file < dio->final_block_in_request) {
|
|
|
|
page = dio_get_page(dio);
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (dio->blocks_available == 0) {
|
|
|
|
/*
|
|
|
|
* Need to go and map some more disk
|
|
|
|
*/
|
|
|
|
unsigned long blkmask;
|
|
|
|
unsigned long dio_remainder;
|
|
|
|
|
|
|
|
ret = get_more_blocks(dio);
|
|
|
|
if (ret) {
|
|
|
|
page_cache_release(page);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!buffer_mapped(map_bh))
|
|
|
|
goto do_holes;
|
|
|
|
|
|
|
|
dio->blocks_available =
|
|
|
|
map_bh->b_size >> dio->blkbits;
|
|
|
|
dio->next_block_for_io =
|
|
|
|
map_bh->b_blocknr << dio->blkfactor;
|
|
|
|
if (buffer_new(map_bh))
|
|
|
|
clean_blockdev_aliases(dio);
|
|
|
|
|
|
|
|
if (!dio->blkfactor)
|
|
|
|
goto do_holes;
|
|
|
|
|
|
|
|
blkmask = (1 << dio->blkfactor) - 1;
|
|
|
|
dio_remainder = (dio->block_in_file & blkmask);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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))
|
|
|
|
dio->next_block_for_io += dio_remainder;
|
|
|
|
dio->blocks_available -= dio_remainder;
|
|
|
|
}
|
|
|
|
do_holes:
|
|
|
|
/* Handle holes */
|
|
|
|
if (!buffer_mapped(map_bh)) {
|
[PATCH] fix O_DIRECT read of last block in a sparse file
Currently, if you open a file O_DIRECT, truncate it to a size that is not a
multiple of the disk block size, and then try to read the last block in the
file, the read will return 0. The problem is in do_direct_IO, here:
/* Handle holes */
if (!buffer_mapped(map_bh)) {
char *kaddr;
...
if (dio->block_in_file >=
i_size_read(dio->inode)>>blkbits) {
/* We hit eof */
page_cache_release(page);
goto out;
}
We shift off any remaining bytes in the final block of the I/O, resulting
in a 0-sized read. I've attached a patch that fixes this. I'm not happy
about how ugly the math is getting, so suggestions are more than welcome.
I've tested this with a simple program that performs the steps outlined for
reproducing the problem above. Without the patch, we get a 0-sized result
from read. With the patch, we get the correct return value from the short
read.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Suparna Bhattacharya <suparna@in.ibm.com>
Cc: Mingming Cao <cmm@us.ibm.com>
Cc: Joel Becker <Joel.Becker@oracle.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-03 18:04:27 +07:00
|
|
|
loff_t i_size_aligned;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* AKPM: eargh, -ENOTBLK is a hack */
|
2006-06-13 13:26:10 +07:00
|
|
|
if (dio->rw & WRITE) {
|
2005-04-17 05:20:36 +07:00
|
|
|
page_cache_release(page);
|
|
|
|
return -ENOTBLK;
|
|
|
|
}
|
|
|
|
|
[PATCH] fix O_DIRECT read of last block in a sparse file
Currently, if you open a file O_DIRECT, truncate it to a size that is not a
multiple of the disk block size, and then try to read the last block in the
file, the read will return 0. The problem is in do_direct_IO, here:
/* Handle holes */
if (!buffer_mapped(map_bh)) {
char *kaddr;
...
if (dio->block_in_file >=
i_size_read(dio->inode)>>blkbits) {
/* We hit eof */
page_cache_release(page);
goto out;
}
We shift off any remaining bytes in the final block of the I/O, resulting
in a 0-sized read. I've attached a patch that fixes this. I'm not happy
about how ugly the math is getting, so suggestions are more than welcome.
I've tested this with a simple program that performs the steps outlined for
reproducing the problem above. Without the patch, we get a 0-sized result
from read. With the patch, we get the correct return value from the short
read.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Suparna Bhattacharya <suparna@in.ibm.com>
Cc: Mingming Cao <cmm@us.ibm.com>
Cc: Joel Becker <Joel.Becker@oracle.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-03 18:04:27 +07:00
|
|
|
/*
|
|
|
|
* 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);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dio->block_in_file >=
|
[PATCH] fix O_DIRECT read of last block in a sparse file
Currently, if you open a file O_DIRECT, truncate it to a size that is not a
multiple of the disk block size, and then try to read the last block in the
file, the read will return 0. The problem is in do_direct_IO, here:
/* Handle holes */
if (!buffer_mapped(map_bh)) {
char *kaddr;
...
if (dio->block_in_file >=
i_size_read(dio->inode)>>blkbits) {
/* We hit eof */
page_cache_release(page);
goto out;
}
We shift off any remaining bytes in the final block of the I/O, resulting
in a 0-sized read. I've attached a patch that fixes this. I'm not happy
about how ugly the math is getting, so suggestions are more than welcome.
I've tested this with a simple program that performs the steps outlined for
reproducing the problem above. Without the patch, we get a 0-sized result
from read. With the patch, we get the correct return value from the short
read.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Suparna Bhattacharya <suparna@in.ibm.com>
Cc: Mingming Cao <cmm@us.ibm.com>
Cc: Joel Becker <Joel.Becker@oracle.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-03 18:04:27 +07:00
|
|
|
i_size_aligned >> blkbits) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/* We hit eof */
|
|
|
|
page_cache_release(page);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-02-05 13:28:29 +07:00
|
|
|
zero_user(page, block_in_page << blkbits,
|
|
|
|
1 << blkbits);
|
2005-04-17 05:20:36 +07:00
|
|
|
dio->block_in_file++;
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
if (unlikely(dio->blkfactor && !dio->start_zero_done))
|
|
|
|
dio_zero_block(dio, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Work out, in this_chunk_blocks, how much disk we
|
|
|
|
* can add to this page
|
|
|
|
*/
|
|
|
|
this_chunk_blocks = dio->blocks_available;
|
|
|
|
u = (PAGE_SIZE - offset_in_page) >> blkbits;
|
|
|
|
if (this_chunk_blocks > u)
|
|
|
|
this_chunk_blocks = u;
|
|
|
|
u = dio->final_block_in_request - dio->block_in_file;
|
|
|
|
if (this_chunk_blocks > u)
|
|
|
|
this_chunk_blocks = u;
|
|
|
|
this_chunk_bytes = this_chunk_blocks << blkbits;
|
|
|
|
BUG_ON(this_chunk_bytes == 0);
|
|
|
|
|
|
|
|
dio->boundary = buffer_boundary(map_bh);
|
|
|
|
ret = submit_page_section(dio, page, offset_in_page,
|
|
|
|
this_chunk_bytes, dio->next_block_for_io);
|
|
|
|
if (ret) {
|
|
|
|
page_cache_release(page);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
dio->next_block_for_io += this_chunk_blocks;
|
|
|
|
|
|
|
|
dio->block_in_file += this_chunk_blocks;
|
|
|
|
block_in_page += this_chunk_blocks;
|
|
|
|
dio->blocks_available -= this_chunk_blocks;
|
|
|
|
next_block:
|
2006-04-01 06:10:13 +07:00
|
|
|
BUG_ON(dio->block_in_file > dio->final_block_in_request);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dio->block_in_file == dio->final_block_in_request)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Drop the ref which was taken in get_user_pages() */
|
|
|
|
page_cache_release(page);
|
|
|
|
block_in_page = 0;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-01-10 06:59:24 +07:00
|
|
|
* Releases both i_mutex and i_alloc_sem
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
static ssize_t
|
|
|
|
direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
|
|
|
|
const struct iovec *iov, loff_t offset, unsigned long nr_segs,
|
2006-03-26 16:38:02 +07:00
|
|
|
unsigned blkbits, get_block_t get_block, dio_iodone_t end_io,
|
2010-05-23 22:00:55 +07:00
|
|
|
dio_submit_t submit_io, struct dio *dio)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long user_addr;
|
2006-12-10 17:21:07 +07:00
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
int seg;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
ssize_t ret2;
|
|
|
|
size_t bytes;
|
|
|
|
|
|
|
|
dio->inode = inode;
|
|
|
|
dio->rw = rw;
|
|
|
|
dio->blkbits = blkbits;
|
|
|
|
dio->blkfactor = inode->i_blkbits - blkbits;
|
|
|
|
dio->block_in_file = offset >> blkbits;
|
|
|
|
|
2006-03-26 16:38:02 +07:00
|
|
|
dio->get_block = get_block;
|
2005-04-17 05:20:36 +07:00
|
|
|
dio->end_io = end_io;
|
2010-05-23 22:00:55 +07:00
|
|
|
dio->submit_io = submit_io;
|
2005-04-17 05:20:36 +07:00
|
|
|
dio->final_block_in_bio = -1;
|
|
|
|
dio->next_block_for_io = -1;
|
|
|
|
|
|
|
|
dio->iocb = iocb;
|
2005-04-17 05:25:50 +07:00
|
|
|
dio->i_size = i_size_read(inode);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_init(&dio->bio_lock);
|
2006-12-10 17:21:07 +07:00
|
|
|
dio->refcount = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In case of non-aligned buffers, we may need 2 more
|
|
|
|
* pages since we need to zero out first and last block.
|
|
|
|
*/
|
|
|
|
if (unlikely(dio->blkfactor))
|
|
|
|
dio->pages_in_io = 2;
|
|
|
|
|
|
|
|
for (seg = 0; seg < nr_segs; seg++) {
|
|
|
|
user_addr = (unsigned long)iov[seg].iov_base;
|
|
|
|
dio->pages_in_io +=
|
|
|
|
((user_addr+iov[seg].iov_len +PAGE_SIZE-1)/PAGE_SIZE
|
|
|
|
- user_addr/PAGE_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (seg = 0; seg < nr_segs; seg++) {
|
|
|
|
user_addr = (unsigned long)iov[seg].iov_base;
|
|
|
|
dio->size += bytes = iov[seg].iov_len;
|
|
|
|
|
|
|
|
/* Index into the first page of the first block */
|
|
|
|
dio->first_block_in_page = (user_addr & ~PAGE_MASK) >> blkbits;
|
|
|
|
dio->final_block_in_request = dio->block_in_file +
|
|
|
|
(bytes >> blkbits);
|
|
|
|
/* Page fetching state */
|
|
|
|
dio->head = 0;
|
|
|
|
dio->tail = 0;
|
|
|
|
dio->curr_page = 0;
|
|
|
|
|
|
|
|
dio->total_pages = 0;
|
|
|
|
if (user_addr & (PAGE_SIZE-1)) {
|
|
|
|
dio->total_pages++;
|
|
|
|
bytes -= PAGE_SIZE - (user_addr & (PAGE_SIZE - 1));
|
|
|
|
}
|
|
|
|
dio->total_pages += (bytes + PAGE_SIZE - 1) / PAGE_SIZE;
|
|
|
|
dio->curr_user_address = user_addr;
|
|
|
|
|
|
|
|
ret = do_direct_IO(dio);
|
|
|
|
|
|
|
|
dio->result += iov[seg].iov_len -
|
|
|
|
((dio->final_block_in_request - dio->block_in_file) <<
|
|
|
|
blkbits);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
dio_cleanup(dio);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} /* end iovec loop */
|
|
|
|
|
2010-05-23 22:00:55 +07:00
|
|
|
if (ret == -ENOTBLK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* The remaining part of the request will be
|
|
|
|
* be handled by buffered I/O when we return
|
|
|
|
*/
|
|
|
|
ret = 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, 1);
|
|
|
|
|
|
|
|
if (dio->cur_page) {
|
|
|
|
ret2 = dio_send_cur_page(dio);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = ret2;
|
|
|
|
page_cache_release(dio->cur_page);
|
|
|
|
dio->cur_page = NULL;
|
|
|
|
}
|
|
|
|
if (dio->bio)
|
|
|
|
dio_bio_submit(dio);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All block lookups have been performed. For READ requests
|
2006-01-10 06:59:24 +07:00
|
|
|
* we can let i_mutex go now that its achieved its purpose
|
2005-04-17 05:20:36 +07:00
|
|
|
* of protecting us from looking up uninitialized blocks.
|
|
|
|
*/
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
if (rw == READ && (dio->flags & DIO_LOCKING))
|
2006-01-10 06:59:24 +07:00
|
|
|
mutex_unlock(&dio->inode->i_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2006-12-10 17:21:05 +07:00
|
|
|
* 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.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-12-10 17:21:05 +07:00
|
|
|
BUG_ON(ret == -EIOCBQUEUED);
|
|
|
|
if (dio->is_async && ret == 0 && dio->result &&
|
|
|
|
((rw & READ) || (dio->result == dio->size)))
|
|
|
|
ret = -EIOCBQUEUED;
|
2006-12-10 17:20:59 +07:00
|
|
|
|
2009-10-03 05:57:36 +07:00
|
|
|
if (ret != -EIOCBQUEUED) {
|
|
|
|
/* All IO is now issued, send it on its way */
|
|
|
|
blk_run_address_space(inode->i_mapping);
|
2006-12-10 17:20:54 +07:00
|
|
|
dio_await_completion(dio);
|
2009-10-03 05:57:36 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-10 17:21:05 +07:00
|
|
|
/*
|
|
|
|
* Sync will always be dropping the final ref and completing the
|
2006-12-10 17:21:07 +07:00
|
|
|
* 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.
|
2006-12-10 17:21:05 +07:00
|
|
|
*/
|
2006-12-10 17:21:07 +07:00
|
|
|
spin_lock_irqsave(&dio->bio_lock, flags);
|
|
|
|
ret2 = --dio->refcount;
|
|
|
|
spin_unlock_irqrestore(&dio->bio_lock, flags);
|
2007-07-04 05:28:55 +07:00
|
|
|
|
2006-12-10 17:21:07 +07:00
|
|
|
if (ret2 == 0) {
|
2010-07-19 04:17:09 +07:00
|
|
|
ret = dio_complete(dio, offset, ret, false);
|
2006-12-10 17:21:05 +07:00
|
|
|
kfree(dio);
|
|
|
|
} else
|
|
|
|
BUG_ON(ret != -EIOCBQUEUED);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-06-04 16:29:53 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
* For reads and writes i_alloc_sem is taken in shared mode and released
|
|
|
|
* on I/O completion (which may happen asynchronously after returning to
|
|
|
|
* the caller).
|
|
|
|
*
|
|
|
|
* - 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.
|
|
|
|
* For reads and writes both i_mutex and i_alloc_sem are not held on
|
|
|
|
* entry and are never taken.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t
|
2010-06-04 16:29:53 +07:00
|
|
|
__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
|
2005-04-17 05:20:36 +07:00
|
|
|
struct block_device *bdev, const struct iovec *iov, loff_t offset,
|
2006-03-26 16:38:02 +07:00
|
|
|
unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
|
2010-05-23 22:00:55 +07:00
|
|
|
dio_submit_t submit_io, int flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int seg;
|
|
|
|
size_t size;
|
|
|
|
unsigned long addr;
|
|
|
|
unsigned blkbits = inode->i_blkbits;
|
|
|
|
unsigned bdev_blkbits = 0;
|
|
|
|
unsigned blocksize_mask = (1 << blkbits) - 1;
|
|
|
|
ssize_t retval = -EINVAL;
|
|
|
|
loff_t end = offset;
|
|
|
|
struct dio *dio;
|
|
|
|
|
|
|
|
if (rw & WRITE)
|
2009-11-26 15:45:40 +07:00
|
|
|
rw = WRITE_ODIRECT_PLUG;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (bdev)
|
2009-05-23 04:17:49 +07:00
|
|
|
bdev_blkbits = blksize_bits(bdev_logical_block_size(bdev));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (offset & blocksize_mask) {
|
|
|
|
if (bdev)
|
|
|
|
blkbits = bdev_blkbits;
|
|
|
|
blocksize_mask = (1 << blkbits) - 1;
|
|
|
|
if (offset & blocksize_mask)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the memory alignment. Blocks cannot straddle pages */
|
|
|
|
for (seg = 0; seg < nr_segs; seg++) {
|
|
|
|
addr = (unsigned long)iov[seg].iov_base;
|
|
|
|
size = iov[seg].iov_len;
|
|
|
|
end += size;
|
|
|
|
if ((addr & blocksize_mask) || (size & blocksize_mask)) {
|
|
|
|
if (bdev)
|
|
|
|
blkbits = bdev_blkbits;
|
|
|
|
blocksize_mask = (1 << blkbits) - 1;
|
|
|
|
if ((addr & blocksize_mask) || (size & blocksize_mask))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-16 07:47:49 +07:00
|
|
|
dio = kmalloc(sizeof(*dio), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = -ENOMEM;
|
|
|
|
if (!dio)
|
|
|
|
goto out;
|
2009-12-16 07:47:49 +07:00
|
|
|
/*
|
|
|
|
* 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));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
dio->flags = flags;
|
|
|
|
if (dio->flags & DIO_LOCKING) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/* watch out for a 0 len io from a tricksy fs */
|
|
|
|
if (rw == READ && end > offset) {
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
struct address_space *mapping =
|
|
|
|
iocb->ki_filp->f_mapping;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
/* will be released by direct_io_worker */
|
|
|
|
mutex_lock(&inode->i_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = filemap_write_and_wait_range(mapping, offset,
|
|
|
|
end - 1);
|
|
|
|
if (retval) {
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(dio);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
direct-io: cleanup blockdev_direct_IO locking
Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.
This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.
Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.
Also revamp the documentation of the locking scheme to actually make
sense.
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Badari Pulavarty <pbadari@us.ibm.com>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alex Elder <aelder@sgi.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-16 07:47:50 +07:00
|
|
|
/*
|
|
|
|
* Will be released at I/O completion, possibly in a
|
|
|
|
* different thread.
|
|
|
|
*/
|
|
|
|
down_read_non_owner(&inode->i_alloc_sem);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For file extending writes updating i_size before data
|
|
|
|
* writeouts complete can expose uninitialized blocks. So
|
|
|
|
* even for AIO, we need to wait for i/o to complete before
|
|
|
|
* returning in this case.
|
|
|
|
*/
|
2006-06-13 13:26:10 +07:00
|
|
|
dio->is_async = !is_sync_kiocb(iocb) && !((rw & WRITE) &&
|
2005-04-17 05:20:36 +07:00
|
|
|
(end > i_size_read(inode)));
|
|
|
|
|
|
|
|
retval = direct_io_worker(rw, iocb, inode, iov, offset,
|
2010-05-23 22:00:55 +07:00
|
|
|
nr_segs, blkbits, get_block, end_io,
|
|
|
|
submit_io, dio);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
fs: introduce new truncate sequence
Introduce a new truncate calling sequence into fs/mm subsystems. Rather than
setattr > vmtruncate > truncate, have filesystems call their truncate sequence
from ->setattr if filesystem specific operations are required. vmtruncate is
deprecated, and truncate_pagecache and inode_newsize_ok helpers introduced
previously should be used.
simple_setattr is introduced for simple in-ram filesystems to implement
the new truncate sequence. Eventually all filesystems should be converted
to implement a setattr, and the default code in notify_change should go
away.
simple_setsize is also introduced to perform just the ATTR_SIZE portion
of simple_setattr (ie. changing i_size and trimming pagecache).
To implement the new truncate sequence:
- filesystem specific manipulations (eg freeing blocks) must be done in
the setattr method rather than ->truncate.
- vmtruncate can not be used by core code to trim blocks past i_size in
the event of write failure after allocation, so this must be performed
in the fs code.
- convert usage of helpers block_write_begin, nobh_write_begin,
cont_write_begin, and *blockdev_direct_IO* to use _newtrunc postfixed
variants. These avoid calling vmtruncate to trim blocks (see previous).
- inode_setattr should not be used. generic_setattr is a new function
to be used to copy simple attributes into the generic inode.
- make use of the better opportunity to handle errors with the new sequence.
Big problem with the previous calling sequence: the filesystem is not called
until i_size has already changed. This means it is not allowed to fail the
call, and also it does not know what the previous i_size was. Also, generic
code calling vmtruncate to truncate allocated blocks in case of error had
no good way to return a meaningful error (or, for example, atomically handle
block deallocation).
Cc: Christoph Hellwig <hch@lst.de>
Acked-by: Jan Kara <jack@suse.cz>
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-05-26 22:05:33 +07:00
|
|
|
out:
|
|
|
|
return retval;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
EXPORT_SYMBOL(__blockdev_direct_IO);
|