2006-10-11 02:20:50 -06:00
|
|
|
/*
|
2006-10-11 02:20:53 -06:00
|
|
|
* linux/fs/ext4/file.c
|
2006-10-11 02:20:50 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1993, 1994, 1995
|
|
|
|
* Remy Card (card@masi.ibp.fr)
|
|
|
|
* Laboratoire MASI - Institut Blaise Pascal
|
|
|
|
* Universite Pierre et Marie Curie (Paris VI)
|
|
|
|
*
|
|
|
|
* from
|
|
|
|
*
|
|
|
|
* linux/fs/minix/file.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4 fs regular file handling primitives
|
2006-10-11 02:20:50 -06:00
|
|
|
*
|
|
|
|
* 64-bit file support on 64-bit platforms by Jakub Jelinek
|
|
|
|
* (jj@sunsite.ms.mff.cuni.cz)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/fs.h>
|
2006-10-11 02:21:01 -06:00
|
|
|
#include <linux/jbd2.h>
|
2009-06-13 08:09:48 -06:00
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/path.h>
|
2010-03-03 07:05:07 -07:00
|
|
|
#include <linux/quotaops.h>
|
2008-04-29 16:13:32 -06:00
|
|
|
#include "ext4.h"
|
|
|
|
#include "ext4_jbd2.h"
|
2006-10-11 02:20:50 -06:00
|
|
|
#include "xattr.h"
|
|
|
|
#include "acl.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called when an inode is released. Note that this is different
|
2006-10-11 02:20:53 -06:00
|
|
|
* from ext4_file_open: open gets called at every open, but release
|
2006-10-11 02:20:50 -06:00
|
|
|
* gets called only when /all/ the files are closed.
|
|
|
|
*/
|
2008-09-08 20:25:24 -06:00
|
|
|
static int ext4_release_file(struct inode *inode, struct file *filp)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2010-01-24 12:34:07 -07:00
|
|
|
if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
|
2009-02-24 06:21:14 -07:00
|
|
|
ext4_alloc_da_blocks(inode);
|
2010-01-24 12:34:07 -07:00
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
|
2009-02-24 06:21:14 -07:00
|
|
|
}
|
2006-10-11 02:20:50 -06:00
|
|
|
/* if we are the last writer on the inode, drop the block reservation */
|
|
|
|
if ((filp->f_mode & FMODE_WRITE) &&
|
2009-03-27 20:36:43 -06:00
|
|
|
(atomic_read(&inode->i_writecount) == 1) &&
|
|
|
|
!EXT4_I(inode)->i_reserved_data_blocks)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2008-01-28 21:58:26 -07:00
|
|
|
down_write(&EXT4_I(inode)->i_data_sem);
|
2008-10-10 07:40:52 -06:00
|
|
|
ext4_discard_preallocations(inode);
|
2008-01-28 21:58:26 -07:00
|
|
|
up_write(&EXT4_I(inode)->i_data_sem);
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
if (is_dx(inode) && filp->private_data)
|
2006-10-11 02:20:53 -06:00
|
|
|
ext4_htree_free_dir_info(filp->private_data);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-05 09:31:55 -06:00
|
|
|
void ext4_unwritten_wait(struct inode *inode)
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
{
|
|
|
|
wait_queue_head_t *wq = ext4_ioend_wq(inode);
|
|
|
|
|
2012-09-28 21:24:52 -06:00
|
|
|
wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This tests whether the IO in question is block-aligned or not.
|
|
|
|
* Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
|
|
|
|
* are converted to written only after the IO is complete. Until they are
|
|
|
|
* mapped, these blocks appear as holes, so dio_zero_block() will assume that
|
|
|
|
* it needs to zero out portions of the start and/or end block. If 2 AIO
|
|
|
|
* threads are at work on the same unwritten block, they must be synchronized
|
|
|
|
* or one thread will zero the other's data, causing corruption.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos)
|
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
int blockmask = sb->s_blocksize - 1;
|
|
|
|
size_t count = iov_length(iov, nr_segs);
|
|
|
|
loff_t final_size = pos + count;
|
|
|
|
|
|
|
|
if (pos >= inode->i_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((pos & blockmask) || (final_size & blockmask))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
static ssize_t
|
2012-07-09 14:29:29 -06:00
|
|
|
ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2012-07-22 18:19:31 -06:00
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct blk_plug plug;
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
int unaligned_aio = 0;
|
2012-05-28 16:06:51 -06:00
|
|
|
ssize_t ret;
|
2012-07-22 18:19:31 -06:00
|
|
|
int overwrite = 0;
|
|
|
|
size_t length = iov_length(iov, nr_segs);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2012-07-09 14:29:29 -06:00
|
|
|
if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
|
|
|
|
!is_sync_kiocb(iocb))
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
|
2008-01-28 21:58:27 -07:00
|
|
|
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
/* Unaligned direct AIO must be serialized; see comment above */
|
|
|
|
if (unaligned_aio) {
|
|
|
|
static unsigned long unaligned_warn_time;
|
|
|
|
|
|
|
|
/* Warn about this once per day */
|
|
|
|
if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
|
|
|
|
ext4_msg(inode->i_sb, KERN_WARNING,
|
|
|
|
"Unaligned AIO/DIO on inode %ld by %s; "
|
|
|
|
"performance will be poor.",
|
|
|
|
inode->i_ino, current->comm);
|
|
|
|
mutex_lock(ext4_aio_mutex(inode));
|
2012-09-28 21:24:52 -06:00
|
|
|
ext4_unwritten_wait(inode);
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
}
|
|
|
|
|
2012-07-22 18:19:31 -06:00
|
|
|
BUG_ON(iocb->ki_pos != pos);
|
|
|
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
blk_start_plug(&plug);
|
|
|
|
|
|
|
|
iocb->private = &overwrite;
|
|
|
|
|
|
|
|
/* check whether we do a DIO overwrite or not */
|
|
|
|
if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
|
|
|
|
!file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
|
|
|
|
struct ext4_map_blocks map;
|
|
|
|
unsigned int blkbits = inode->i_blkbits;
|
|
|
|
int err, len;
|
|
|
|
|
|
|
|
map.m_lblk = pos >> blkbits;
|
|
|
|
map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
|
|
|
|
- map.m_lblk;
|
|
|
|
len = map.m_len;
|
|
|
|
|
|
|
|
err = ext4_map_blocks(NULL, inode, &map, 0);
|
|
|
|
/*
|
|
|
|
* 'err==len' means that all of blocks has been preallocated no
|
|
|
|
* matter they are initialized or not. For excluding
|
|
|
|
* uninitialized extents, we need to check m_flags. There are
|
|
|
|
* two conditions that indicate for initialized extents.
|
|
|
|
* 1) If we hit extent cache, EXT4_MAP_MAPPED flag is returned;
|
|
|
|
* 2) If we do a real lookup, non-flags are returned.
|
|
|
|
* So we should check these two conditions.
|
|
|
|
*/
|
|
|
|
if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
|
|
|
|
overwrite = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
|
|
|
if (ret > 0 || ret == -EIOCBQUEUED) {
|
|
|
|
ssize_t err;
|
|
|
|
|
|
|
|
err = generic_write_sync(file, pos, ret);
|
|
|
|
if (err < 0 && ret > 0)
|
|
|
|
ret = err;
|
|
|
|
}
|
|
|
|
blk_finish_plug(&plug);
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
|
|
|
|
if (unaligned_aio)
|
|
|
|
mutex_unlock(ext4_aio_mutex(inode));
|
|
|
|
|
|
|
|
return ret;
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2006-10-11 02:20:53 -06:00
|
|
|
ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
|
2006-10-11 02:20:50 -06:00
|
|
|
unsigned long nr_segs, loff_t pos)
|
|
|
|
{
|
2009-08-18 09:48:27 -06:00
|
|
|
struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
|
2012-05-28 16:06:51 -06:00
|
|
|
ssize_t ret;
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2008-01-28 21:58:27 -07:00
|
|
|
/*
|
|
|
|
* If we have encountered a bitmap-format file, the size limit
|
|
|
|
* is smaller than s_maxbytes, which is for extent-mapped files.
|
|
|
|
*/
|
|
|
|
|
2010-05-16 20:00:00 -06:00
|
|
|
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
|
2008-01-28 21:58:27 -07:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
|
|
|
size_t length = iov_length(iov, nr_segs);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2010-07-27 09:56:07 -06:00
|
|
|
if ((pos > sbi->s_bitmap_maxbytes ||
|
|
|
|
(pos == sbi->s_bitmap_maxbytes && length > 0)))
|
2008-01-28 21:58:27 -07:00
|
|
|
return -EFBIG;
|
|
|
|
|
|
|
|
if (pos + length > sbi->s_bitmap_maxbytes) {
|
|
|
|
nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
|
|
|
|
sbi->s_bitmap_maxbytes - pos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-09 14:29:29 -06:00
|
|
|
if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
|
|
|
|
ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
|
|
|
|
else
|
|
|
|
ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
|
ext4: serialize unaligned asynchronous DIO
ext4 has a data corruption case when doing non-block-aligned
asynchronous direct IO into a sparse file, as demonstrated
by xfstest 240.
The root cause is that while ext4 preallocates space in the
hole, mappings of that space still look "new" and
dio_zero_block() will zero out the unwritten portions. When
more than one AIO thread is going, they both find this "new"
block and race to zero out their portion; this is uncoordinated
and causes data corruption.
Dave Chinner fixed this for xfs by simply serializing all
unaligned asynchronous direct IO. I've done the same here.
The difference is that we only wait on conversions, not all IO.
This is a very big hammer, and I'm not very pleased with
stuffing this into ext4_file_write(). But since ext4 is
DIO_LOCKING, we need to serialize it at this high level.
I tried to move this into ext4_ext_direct_IO, but by then
we have the i_mutex already, and we will wait on the
work queue to do conversions - which must also take the
i_mutex. So that won't work.
This was originally exposed by qemu-kvm installing to
a raw disk image with a normal sector-63 alignment. I've
tested a backport of this patch with qemu, and it does
avoid the corruption. It is also quite a lot slower
(14 min for package installs, vs. 8 min for well-aligned)
but I'll take slow correctness over fast corruption any day.
Mingming suggested that we can track outstanding
conversions, and wait on those so that non-sparse
files won't be affected, and I've implemented that here;
unaligned AIO to nonsparse files won't take a perf hit.
[tytso@mit.edu: Keep the mutex as a hashed array instead
of bloating the ext4 inode]
[tytso@mit.edu: Fix up namespace issues so that global
variables are protected with an "ext4_" prefix.]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2011-02-12 06:17:34 -07:00
|
|
|
|
|
|
|
return ret;
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
|
2009-09-27 12:29:37 -06:00
|
|
|
static const struct vm_operations_struct ext4_file_vm_ops = {
|
2008-07-11 17:27:31 -06:00
|
|
|
.fault = filemap_fault,
|
|
|
|
.page_mkwrite = ext4_page_mkwrite,
|
2012-10-08 17:28:46 -06:00
|
|
|
.remap_pages = generic_file_remap_pages,
|
2008-07-11 17:27:31 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
|
|
|
|
if (!mapping->a_ops->readpage)
|
|
|
|
return -ENOEXEC;
|
|
|
|
file_accessed(file);
|
|
|
|
vma->vm_ops = &ext4_file_vm_ops;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-13 08:09:48 -06:00
|
|
|
static int ext4_file_open(struct inode * inode, struct file * filp)
|
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
2011-01-10 10:29:43 -07:00
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
2009-06-13 08:09:48 -06:00
|
|
|
struct vfsmount *mnt = filp->f_path.mnt;
|
|
|
|
struct path path;
|
|
|
|
char buf[64], *cp;
|
|
|
|
|
|
|
|
if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
|
|
|
|
!(sb->s_flags & MS_RDONLY))) {
|
|
|
|
sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
|
|
|
|
/*
|
|
|
|
* Sample where the filesystem has been mounted and
|
|
|
|
* store it in the superblock for sysadmin convenience
|
|
|
|
* when trying to sort through large numbers of block
|
|
|
|
* devices or filesystem images.
|
|
|
|
*/
|
|
|
|
memset(buf, 0, sizeof(buf));
|
2010-01-23 18:10:29 -07:00
|
|
|
path.mnt = mnt;
|
|
|
|
path.dentry = mnt->mnt_root;
|
2009-06-13 08:09:48 -06:00
|
|
|
cp = d_path(&path, buf, sizeof(buf));
|
|
|
|
if (!IS_ERR(cp)) {
|
2012-07-22 18:31:31 -06:00
|
|
|
handle_t *handle;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
handle = ext4_journal_start_sb(sb, 1);
|
|
|
|
if (IS_ERR(handle))
|
|
|
|
return PTR_ERR(handle);
|
|
|
|
err = ext4_journal_get_write_access(handle, sbi->s_sbh);
|
|
|
|
if (err) {
|
|
|
|
ext4_journal_stop(handle);
|
|
|
|
return err;
|
|
|
|
}
|
2011-10-25 07:18:41 -06:00
|
|
|
strlcpy(sbi->s_es->s_last_mounted, cp,
|
|
|
|
sizeof(sbi->s_es->s_last_mounted));
|
2012-07-22 18:31:31 -06:00
|
|
|
ext4_handle_dirty_super(handle, sb);
|
|
|
|
ext4_journal_stop(handle);
|
2009-06-13 08:09:48 -06:00
|
|
|
}
|
|
|
|
}
|
2011-01-10 10:29:43 -07:00
|
|
|
/*
|
|
|
|
* Set up the jbd2_inode if we are opening the inode for
|
|
|
|
* writing and the journal is present
|
|
|
|
*/
|
|
|
|
if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {
|
|
|
|
struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (!ei->jinode) {
|
|
|
|
if (!jinode) {
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
ei->jinode = jinode;
|
|
|
|
jbd2_journal_init_jbd_inode(ei->jinode, inode);
|
|
|
|
jinode = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
if (unlikely(jinode != NULL))
|
|
|
|
jbd2_free_inode(jinode);
|
|
|
|
}
|
2010-03-03 07:05:06 -07:00
|
|
|
return dquot_file_open(inode, filp);
|
2009-06-13 08:09:48 -06:00
|
|
|
}
|
|
|
|
|
2010-10-27 19:30:06 -06:00
|
|
|
/*
|
2012-04-30 12:14:03 -06:00
|
|
|
* ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
|
|
|
|
* by calling generic_file_llseek_size() with the appropriate maxbytes
|
|
|
|
* value for each.
|
2010-10-27 19:30:06 -06:00
|
|
|
*/
|
|
|
|
loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
loff_t maxbytes;
|
|
|
|
|
|
|
|
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
|
|
|
|
maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
|
|
|
|
else
|
|
|
|
maxbytes = inode->i_sb->s_maxbytes;
|
|
|
|
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-04-30 12:11:29 -06:00
|
|
|
return generic_file_llseek_size(file, offset, origin,
|
|
|
|
maxbytes, i_size_read(inode));
|
2010-10-27 19:30:06 -06:00
|
|
|
}
|
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
const struct file_operations ext4_file_operations = {
|
2010-10-27 19:30:06 -06:00
|
|
|
.llseek = ext4_llseek,
|
2006-10-11 02:20:50 -06:00
|
|
|
.read = do_sync_read,
|
|
|
|
.write = do_sync_write,
|
|
|
|
.aio_read = generic_file_aio_read,
|
2006-10-11 02:20:53 -06:00
|
|
|
.aio_write = ext4_file_write,
|
2008-04-29 20:03:54 -06:00
|
|
|
.unlocked_ioctl = ext4_ioctl,
|
2006-10-11 02:20:50 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-10-11 02:20:53 -06:00
|
|
|
.compat_ioctl = ext4_compat_ioctl,
|
2006-10-11 02:20:50 -06:00
|
|
|
#endif
|
2008-07-11 17:27:31 -06:00
|
|
|
.mmap = ext4_file_mmap,
|
2009-06-13 08:09:48 -06:00
|
|
|
.open = ext4_file_open,
|
2006-10-11 02:20:53 -06:00
|
|
|
.release = ext4_release_file,
|
|
|
|
.fsync = ext4_sync_file,
|
2006-10-11 02:20:50 -06:00
|
|
|
.splice_read = generic_file_splice_read,
|
|
|
|
.splice_write = generic_file_splice_write,
|
2011-01-14 05:07:43 -07:00
|
|
|
.fallocate = ext4_fallocate,
|
2006-10-11 02:20:50 -06:00
|
|
|
};
|
|
|
|
|
2007-02-12 01:55:38 -07:00
|
|
|
const struct inode_operations ext4_file_inode_operations = {
|
2006-10-11 02:20:53 -06:00
|
|
|
.setattr = ext4_setattr,
|
2008-07-11 17:27:31 -06:00
|
|
|
.getattr = ext4_getattr,
|
2008-10-10 18:02:48 -06:00
|
|
|
#ifdef CONFIG_EXT4_FS_XATTR
|
2006-10-11 02:20:50 -06:00
|
|
|
.setxattr = generic_setxattr,
|
|
|
|
.getxattr = generic_getxattr,
|
2006-10-11 02:20:53 -06:00
|
|
|
.listxattr = ext4_listxattr,
|
2006-10-11 02:20:50 -06:00
|
|
|
.removexattr = generic_removexattr,
|
|
|
|
#endif
|
2011-07-23 09:37:31 -06:00
|
|
|
.get_acl = ext4_get_acl,
|
2008-10-06 22:46:36 -06:00
|
|
|
.fiemap = ext4_fiemap,
|
2006-10-11 02:20:50 -06:00
|
|
|
};
|
|
|
|
|