projects
/
powerpc.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
[XFS] Make d_maxiosz report the real maximum (INT_MAX) so we dont
[powerpc.git]
/
fs
/
direct-io.c
diff --git
a/fs/direct-io.c
b/fs/direct-io.c
index
5a674a0
..
30dbbd1
100644
(file)
--- a/
fs/direct-io.c
+++ b/
fs/direct-io.c
@@
-56,7
+56,7
@@
* lock_type is DIO_LOCKING for regular files on direct-IO-naive filesystems.
* This determines whether we need to do the fancy locking which prevents
* direct-IO from being able to read uninitialised disk blocks. If its zero
* lock_type is DIO_LOCKING for regular files on direct-IO-naive filesystems.
* This determines whether we need to do the fancy locking which prevents
* direct-IO from being able to read uninitialised disk blocks. If its zero
- * (blockdev) this locking is not done, and if it is DIO_OWN_LOCKING i_
sem
is
+ * (blockdev) this locking is not done, and if it is DIO_OWN_LOCKING i_
mutex
is
* not held for the entire direct write (taken briefly, initially, during a
* direct read though, but its never held for the duration of a direct-IO).
*/
* not held for the entire direct write (taken briefly, initially, during a
* direct read though, but its never held for the duration of a direct-IO).
*/
@@
-66,6
+66,7
@@
struct dio {
struct bio *bio; /* bio under assembly */
struct inode *inode;
int rw;
struct bio *bio; /* bio under assembly */
struct inode *inode;
int rw;
+ loff_t i_size; /* i_size when submitted */
int lock_type; /* doesn't change */
unsigned blkbits; /* doesn't change */
unsigned blkfactor; /* When we're using an alignment which
int lock_type; /* doesn't change */
unsigned blkbits; /* doesn't change */
unsigned blkfactor; /* When we're using an alignment which
@@
-161,6
+162,7
@@
static int dio_refill_pages(struct dio *dio)
up_read(¤t->mm->mmap_sem);
if (ret < 0 && dio->blocks_available && (dio->rw == WRITE)) {
up_read(¤t->mm->mmap_sem);
if (ret < 0 && dio->blocks_available && (dio->rw == WRITE)) {
+ struct page *page = ZERO_PAGE(dio->curr_user_address);
/*
* A memory fault, but the filesystem has some outstanding
* mapped blocks. We need to use those blocks up to avoid
/*
* A memory fault, but the filesystem has some outstanding
* mapped blocks. We need to use those blocks up to avoid
@@
-168,7
+170,8
@@
static int dio_refill_pages(struct dio *dio)
*/
if (dio->page_errors == 0)
dio->page_errors = ret;
*/
if (dio->page_errors == 0)
dio->page_errors = ret;
- dio->pages[0] = ZERO_PAGE(dio->curr_user_address);
+ page_cache_get(page);
+ dio->pages[0] = page;
dio->head = 0;
dio->tail = 1;
ret = 0;
dio->head = 0;
dio->tail = 1;
ret = 0;
@@
-214,7
+217,7
@@
static struct page *dio_get_page(struct dio *dio)
static void dio_complete(struct dio *dio, loff_t offset, ssize_t bytes)
{
if (dio->end_io && dio->result)
static void dio_complete(struct dio *dio, loff_t offset, ssize_t bytes)
{
if (dio->end_io && dio->result)
- dio->end_io(dio->i
node
, offset, bytes, dio->map_bh.b_private);
+ dio->end_io(dio->i
ocb
, offset, bytes, dio->map_bh.b_private);
if (dio->lock_type == DIO_LOCKING)
up_read(&dio->inode->i_alloc_sem);
}
if (dio->lock_type == DIO_LOCKING)
up_read(&dio->inode->i_alloc_sem);
}
@@
-230,17
+233,29
@@
static void finished_one_bio(struct dio *dio)
spin_lock_irqsave(&dio->bio_lock, flags);
if (dio->bio_count == 1) {
if (dio->is_async) {
spin_lock_irqsave(&dio->bio_lock, flags);
if (dio->bio_count == 1) {
if (dio->is_async) {
+ ssize_t transferred;
+ loff_t offset;
+
/*
* Last reference to the dio is going away.
* Drop spinlock and complete the DIO.
*/
spin_unlock_irqrestore(&dio->bio_lock, flags);
/*
* Last reference to the dio is going away.
* Drop spinlock and complete the DIO.
*/
spin_unlock_irqrestore(&dio->bio_lock, flags);
- dio_complete(dio, dio->block_in_file << dio->blkbits,
- dio->result);
+
+ /* Check for short read case */
+ transferred = dio->result;
+ offset = dio->iocb->ki_pos;
+
+ if ((dio->rw == READ) &&
+ ((offset + transferred) > dio->i_size))
+ transferred = dio->i_size - offset;
+
+ dio_complete(dio, offset, transferred);
+
/* Complete AIO later if falling back to buffered i/o */
if (dio->result == dio->size ||
((dio->rw == READ) && dio->result)) {
/* Complete AIO later if falling back to buffered i/o */
if (dio->result == dio->size ||
((dio->rw == READ) && dio->result)) {
- aio_complete(dio->iocb,
dio->result
, 0);
+ aio_complete(dio->iocb,
transferred
, 0);
kfree(dio);
return;
} else {
kfree(dio);
return;
} else {
@@
-915,7
+930,7
@@
out:
}
/*
}
/*
- * Releases both i_
sem
and i_alloc_sem
+ * Releases both i_
mutex
and i_alloc_sem
*/
static ssize_t
direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
*/
static ssize_t
direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
@@
-951,6
+966,7
@@
direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
dio->page_errors = 0;
dio->result = 0;
dio->iocb = iocb;
dio->page_errors = 0;
dio->result = 0;
dio->iocb = iocb;
+ dio->i_size = i_size_read(inode);
/*
* BIO completion state.
/*
* BIO completion state.
@@
-1046,11
+1062,11
@@
direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
/*
* All block lookups have been performed. For READ requests
/*
* All block lookups have been performed. For READ requests
- * we can let i_
sem
go now that its achieved its purpose
+ * we can let i_
mutex
go now that its achieved its purpose
* of protecting us from looking up uninitialized blocks.
*/
if ((rw == READ) && (dio->lock_type == DIO_LOCKING))
* of protecting us from looking up uninitialized blocks.
*/
if ((rw == READ) && (dio->lock_type == DIO_LOCKING))
-
up(&dio->inode->i_sem
);
+
mutex_unlock(&dio->inode->i_mutex
);
/*
* OK, all BIOs are submitted, so we can decrement bio_count to truly
/*
* OK, all BIOs are submitted, so we can decrement bio_count to truly
@@
-1129,18
+1145,18
@@
direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
* The locking rules are governed by the dio_lock_type parameter.
*
* DIO_NO_LOCKING (no locking, for raw block device access)
* The locking rules are governed by the dio_lock_type parameter.
*
* DIO_NO_LOCKING (no locking, for raw block device access)
- * For writes, i_
sem
is not held on entry; it is never taken.
+ * For writes, i_
mutex
is not held on entry; it is never taken.
*
* DIO_LOCKING (simple locking for regular files)
*
* DIO_LOCKING (simple locking for regular files)
- * For writes we are called under i_
sem and return with i_sem
held, even though
+ * For writes we are called under i_
mutex and return with i_mutex
held, even though
* it is internally dropped.
* it is internally dropped.
- * For reads, i_
sem
is not held on entry, but it is taken and dropped before
+ * For reads, i_
mutex
is not held on entry, but it is taken and dropped before
* returning.
*
* DIO_OWN_LOCKING (filesystem provides synchronisation and handling of
* uninitialised data, allowing parallel direct readers and writers)
* returning.
*
* DIO_OWN_LOCKING (filesystem provides synchronisation and handling of
* uninitialised data, allowing parallel direct readers and writers)
- * For writes we are called without i_
sem
, return without it, never touch it.
- * For reads, i_
sem
is held on entry and will be released before returning.
+ * For writes we are called without i_
mutex
, return without it, never touch it.
+ * For reads, i_
mutex
is held on entry and will be released before returning.
*
* Additional i_alloc_sem locking requirements described inline below.
*/
*
* Additional i_alloc_sem locking requirements described inline below.
*/
@@
-1198,11
+1214,11
@@
__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
* For block device access DIO_NO_LOCKING is used,
* neither readers nor writers do any locking at all
* For regular files using DIO_LOCKING,
* For block device access DIO_NO_LOCKING is used,
* neither readers nor writers do any locking at all
* For regular files using DIO_LOCKING,
- * readers need to grab i_
sem
and i_alloc_sem
- * writers need to grab i_alloc_sem only (i_
sem
is already held)
+ * readers need to grab i_
mutex
and i_alloc_sem
+ * writers need to grab i_alloc_sem only (i_
mutex
is already held)
* For regular files using DIO_OWN_LOCKING,
* neither readers nor writers take any locks here
* For regular files using DIO_OWN_LOCKING,
* neither readers nor writers take any locks here
- * (i_
sem
is already held and release for writers here)
+ * (i_
mutex
is already held and release for writers here)
*/
dio->lock_type = dio_lock_type;
if (dio_lock_type != DIO_NO_LOCKING) {
*/
dio->lock_type = dio_lock_type;
if (dio_lock_type != DIO_NO_LOCKING) {
@@
-1212,7
+1228,7
@@
__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
mapping = iocb->ki_filp->f_mapping;
if (dio_lock_type != DIO_OWN_LOCKING) {
mapping = iocb->ki_filp->f_mapping;
if (dio_lock_type != DIO_OWN_LOCKING) {
-
down(&inode->i_sem
);
+
mutex_lock(&inode->i_mutex
);
reader_with_isem = 1;
}
reader_with_isem = 1;
}
@@
-1224,7
+1240,7
@@
__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
}
if (dio_lock_type == DIO_OWN_LOCKING) {
}
if (dio_lock_type == DIO_OWN_LOCKING) {
-
up(&inode->i_sem
);
+
mutex_unlock(&inode->i_mutex
);
reader_with_isem = 0;
}
}
reader_with_isem = 0;
}
}
@@
-1250,7
+1266,7
@@
__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
out:
if (reader_with_isem)
out:
if (reader_with_isem)
-
up(&inode->i_sem
);
+
mutex_unlock(&inode->i_mutex
);
if (rw & WRITE)
current->flags &= ~PF_SYNCWRITE;
return retval;
if (rw & WRITE)
current->flags &= ~PF_SYNCWRITE;
return retval;