2006-10-11 08:20:50 +00:00
|
|
|
/*
|
2006-10-11 08:20:53 +00:00
|
|
|
* linux/fs/ext4/file.c
|
2006-10-11 08:20:50 +00: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 08:20:53 +00:00
|
|
|
* ext4 fs regular file handling primitives
|
2006-10-11 08:20:50 +00: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 08:21:01 +00:00
|
|
|
#include <linux/jbd2.h>
|
2009-06-13 14:09:48 +00:00
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/path.h>
|
2010-03-03 14:05:07 +00:00
|
|
|
#include <linux/quotaops.h>
|
2012-11-09 02:57:40 +00:00
|
|
|
#include <linux/pagevec.h>
|
2008-04-29 22:13:32 +00:00
|
|
|
#include "ext4.h"
|
|
|
|
#include "ext4_jbd2.h"
|
2006-10-11 08:20:50 +00:00
|
|
|
#include "xattr.h"
|
|
|
|
#include "acl.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called when an inode is released. Note that this is different
|
2006-10-11 08:20:53 +00:00
|
|
|
* from ext4_file_open: open gets called at every open, but release
|
2006-10-11 08:20:50 +00:00
|
|
|
* gets called only when /all/ the files are closed.
|
|
|
|
*/
|
2008-09-09 02:25:24 +00:00
|
|
|
static int ext4_release_file(struct inode *inode, struct file *filp)
|
2006-10-11 08:20:50 +00:00
|
|
|
{
|
2010-01-24 19:34:07 +00:00
|
|
|
if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
|
2009-02-24 13:21:14 +00:00
|
|
|
ext4_alloc_da_blocks(inode);
|
2010-01-24 19:34:07 +00:00
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
|
2009-02-24 13:21:14 +00:00
|
|
|
}
|
2006-10-11 08:20:50 +00:00
|
|
|
/* if we are the last writer on the inode, drop the block reservation */
|
|
|
|
if ((filp->f_mode & FMODE_WRITE) &&
|
2009-03-28 02:36:43 +00:00
|
|
|
(atomic_read(&inode->i_writecount) == 1) &&
|
|
|
|
!EXT4_I(inode)->i_reserved_data_blocks)
|
2006-10-11 08:20:50 +00:00
|
|
|
{
|
2008-01-29 04:58:26 +00:00
|
|
|
down_write(&EXT4_I(inode)->i_data_sem);
|
2008-10-10 13:40:52 +00:00
|
|
|
ext4_discard_preallocations(inode);
|
2008-01-29 04:58:26 +00:00
|
|
|
up_write(&EXT4_I(inode)->i_data_sem);
|
2006-10-11 08:20:50 +00:00
|
|
|
}
|
|
|
|
if (is_dx(inode) && filp->private_data)
|
2006-10-11 08:20:53 +00:00
|
|
|
ext4_htree_free_dir_info(filp->private_data);
|
2006-10-11 08:20:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-05 15:31:55 +00: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 13:17:34 +00:00
|
|
|
{
|
|
|
|
wait_queue_head_t *wq = ext4_ioend_wq(inode);
|
|
|
|
|
2012-09-29 03:24:52 +00: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 13:17:34 +00: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 08:20:50 +00:00
|
|
|
static ssize_t
|
2012-07-09 20:29:29 +00:00
|
|
|
ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos)
|
2006-10-11 08:20:50 +00:00
|
|
|
{
|
2012-07-23 00:19:31 +00: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 13:17:34 +00:00
|
|
|
int unaligned_aio = 0;
|
2012-05-28 22:06:51 +00:00
|
|
|
ssize_t ret;
|
2012-07-23 00:19:31 +00:00
|
|
|
int overwrite = 0;
|
|
|
|
size_t length = iov_length(iov, nr_segs);
|
2006-10-11 08:20:50 +00:00
|
|
|
|
2012-07-09 20:29:29 +00: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 13:17:34 +00:00
|
|
|
unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
|
2008-01-29 04:58:27 +00: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 13:17:34 +00:00
|
|
|
/* Unaligned direct AIO must be serialized; see comment above */
|
|
|
|
if (unaligned_aio) {
|
|
|
|
mutex_lock(ext4_aio_mutex(inode));
|
2012-09-29 03:24:52 +00: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 13:17:34 +00:00
|
|
|
}
|
|
|
|
|
2012-07-23 00:19:31 +00: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 13:17:34 +00:00
|
|
|
|
|
|
|
if (unaligned_aio)
|
|
|
|
mutex_unlock(ext4_aio_mutex(inode));
|
|
|
|
|
|
|
|
return ret;
|
2006-10-11 08:20:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2006-10-11 08:20:53 +00:00
|
|
|
ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
|
2006-10-11 08:20:50 +00:00
|
|
|
unsigned long nr_segs, loff_t pos)
|
|
|
|
{
|
2013-01-23 22:07:38 +00:00
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
2012-05-28 22:06:51 +00:00
|
|
|
ssize_t ret;
|
2006-10-11 08:20:50 +00:00
|
|
|
|
2008-01-29 04:58:27 +00: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-17 02:00:00 +00:00
|
|
|
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
|
2008-01-29 04:58:27 +00:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
|
|
|
size_t length = iov_length(iov, nr_segs);
|
2006-10-11 08:20:50 +00:00
|
|
|
|
2010-07-27 15:56:07 +00:00
|
|
|
if ((pos > sbi->s_bitmap_maxbytes ||
|
|
|
|
(pos == sbi->s_bitmap_maxbytes && length > 0)))
|
2008-01-29 04:58:27 +00: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 20:29:29 +00: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 13:17:34 +00:00
|
|
|
|
|
|
|
return ret;
|
2006-10-11 08:20:50 +00:00
|
|
|
}
|
|
|
|
|
2009-09-27 18:29:37 +00:00
|
|
|
static const struct vm_operations_struct ext4_file_vm_ops = {
|
2008-07-11 23:27:31 +00:00
|
|
|
.fault = filemap_fault,
|
|
|
|
.page_mkwrite = ext4_page_mkwrite,
|
2012-10-08 23:28:46 +00:00
|
|
|
.remap_pages = generic_file_remap_pages,
|
2008-07-11 23:27:31 +00: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 14:09:48 +00: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 17:29:43 +00:00
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
2009-06-13 14:09:48 +00: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-24 01:10:29 +00:00
|
|
|
path.mnt = mnt;
|
|
|
|
path.dentry = mnt->mnt_root;
|
2009-06-13 14:09:48 +00:00
|
|
|
cp = d_path(&path, buf, sizeof(buf));
|
|
|
|
if (!IS_ERR(cp)) {
|
2012-07-23 00:31:31 +00:00
|
|
|
handle_t *handle;
|
|
|
|
int err;
|
|
|
|
|
2013-02-09 02:59:22 +00:00
|
|
|
handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
|
2012-07-23 00:31:31 +00:00
|
|
|
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 13:18:41 +00:00
|
|
|
strlcpy(sbi->s_es->s_last_mounted, cp,
|
|
|
|
sizeof(sbi->s_es->s_last_mounted));
|
2012-07-23 00:31:31 +00:00
|
|
|
ext4_handle_dirty_super(handle, sb);
|
|
|
|
ext4_journal_stop(handle);
|
2009-06-13 14:09:48 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-10 17:29:43 +00: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 14:05:06 +00:00
|
|
|
return dquot_file_open(inode, filp);
|
2009-06-13 14:09:48 +00:00
|
|
|
}
|
|
|
|
|
2012-11-09 02:57:40 +00:00
|
|
|
/*
|
|
|
|
* Here we use ext4_map_blocks() to get a block mapping for a extent-based
|
|
|
|
* file rather than ext4_ext_walk_space() because we can introduce
|
|
|
|
* SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
|
|
|
|
* function. When extent status tree has been fully implemented, it will
|
|
|
|
* track all extent status for a file and we can directly use it to
|
|
|
|
* retrieve the offset for SEEK_DATA/SEEK_HOLE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
|
|
|
|
* lookup page cache to check whether or not there has some data between
|
|
|
|
* [startoff, endoff] because, if this range contains an unwritten extent,
|
|
|
|
* we determine this extent as a data or a hole according to whether the
|
|
|
|
* page cache has data or not.
|
|
|
|
*/
|
|
|
|
static int ext4_find_unwritten_pgoff(struct inode *inode,
|
2012-12-17 23:59:39 +00:00
|
|
|
int whence,
|
2012-11-09 02:57:40 +00:00
|
|
|
struct ext4_map_blocks *map,
|
|
|
|
loff_t *offset)
|
|
|
|
{
|
|
|
|
struct pagevec pvec;
|
|
|
|
unsigned int blkbits;
|
|
|
|
pgoff_t index;
|
|
|
|
pgoff_t end;
|
|
|
|
loff_t endoff;
|
|
|
|
loff_t startoff;
|
|
|
|
loff_t lastoff;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
startoff = *offset;
|
|
|
|
lastoff = startoff;
|
|
|
|
endoff = (map->m_lblk + map->m_len) << blkbits;
|
|
|
|
|
|
|
|
index = startoff >> PAGE_CACHE_SHIFT;
|
|
|
|
end = endoff >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
pagevec_init(&pvec, 0);
|
|
|
|
do {
|
|
|
|
int i, num;
|
|
|
|
unsigned long nr_pages;
|
|
|
|
|
|
|
|
num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
|
|
|
|
nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
|
|
|
|
(pgoff_t)num);
|
|
|
|
if (nr_pages == 0) {
|
2012-12-17 23:59:39 +00:00
|
|
|
if (whence == SEEK_DATA)
|
2012-11-09 02:57:40 +00:00
|
|
|
break;
|
|
|
|
|
2012-12-17 23:59:39 +00:00
|
|
|
BUG_ON(whence != SEEK_HOLE);
|
2012-11-09 02:57:40 +00:00
|
|
|
/*
|
|
|
|
* If this is the first time to go into the loop and
|
|
|
|
* offset is not beyond the end offset, it will be a
|
|
|
|
* hole at this offset
|
|
|
|
*/
|
|
|
|
if (lastoff == startoff || lastoff < endoff)
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is the first time to go into the loop and
|
|
|
|
* offset is smaller than the first page offset, it will be a
|
|
|
|
* hole at this offset.
|
|
|
|
*/
|
2012-12-17 23:59:39 +00:00
|
|
|
if (lastoff == startoff && whence == SEEK_HOLE &&
|
2012-11-09 02:57:40 +00:00
|
|
|
lastoff < page_offset(pvec.pages[0])) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nr_pages; i++) {
|
|
|
|
struct page *page = pvec.pages[i];
|
|
|
|
struct buffer_head *bh, *head;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the current offset is not beyond the end of given
|
|
|
|
* range, it will be a hole.
|
|
|
|
*/
|
2012-12-17 23:59:39 +00:00
|
|
|
if (lastoff < endoff && whence == SEEK_HOLE &&
|
2012-11-09 02:57:40 +00:00
|
|
|
page->index > end) {
|
|
|
|
found = 1;
|
|
|
|
*offset = lastoff;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
lock_page(page);
|
|
|
|
|
|
|
|
if (unlikely(page->mapping != inode->i_mapping)) {
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!page_has_buffers(page)) {
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (page_has_buffers(page)) {
|
|
|
|
lastoff = page_offset(page);
|
|
|
|
bh = head = page_buffers(page);
|
|
|
|
do {
|
|
|
|
if (buffer_uptodate(bh) ||
|
|
|
|
buffer_unwritten(bh)) {
|
2012-12-17 23:59:39 +00:00
|
|
|
if (whence == SEEK_DATA)
|
2012-11-09 02:57:40 +00:00
|
|
|
found = 1;
|
|
|
|
} else {
|
2012-12-17 23:59:39 +00:00
|
|
|
if (whence == SEEK_HOLE)
|
2012-11-09 02:57:40 +00:00
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
if (found) {
|
|
|
|
*offset = max_t(loff_t,
|
|
|
|
startoff, lastoff);
|
|
|
|
unlock_page(page);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
lastoff += bh->b_size;
|
|
|
|
bh = bh->b_this_page;
|
|
|
|
} while (bh != head);
|
|
|
|
}
|
|
|
|
|
|
|
|
lastoff = page_offset(page) + PAGE_SIZE;
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The no. of pages is less than our desired, that would be a
|
|
|
|
* hole in there.
|
|
|
|
*/
|
2012-12-17 23:59:39 +00:00
|
|
|
if (nr_pages < num && whence == SEEK_HOLE) {
|
2012-11-09 02:57:40 +00:00
|
|
|
found = 1;
|
|
|
|
*offset = lastoff;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = pvec.pages[i - 1]->index + 1;
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
} while (index <= end);
|
|
|
|
|
|
|
|
out:
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ext4_seek_data() retrieves the offset for SEEK_DATA.
|
|
|
|
*/
|
|
|
|
static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct ext4_map_blocks map;
|
|
|
|
struct extent_status es;
|
|
|
|
ext4_lblk_t start, last, end;
|
|
|
|
loff_t dataoff, isize;
|
|
|
|
int blkbits;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
|
|
|
|
isize = i_size_read(inode);
|
|
|
|
if (offset >= isize) {
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
start = offset >> blkbits;
|
|
|
|
last = start;
|
|
|
|
end = isize >> blkbits;
|
|
|
|
dataoff = offset;
|
|
|
|
|
|
|
|
do {
|
|
|
|
map.m_lblk = last;
|
|
|
|
map.m_len = end - last + 1;
|
|
|
|
ret = ext4_map_blocks(NULL, inode, &map, 0);
|
|
|
|
if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
|
|
|
|
if (last != start)
|
|
|
|
dataoff = last << blkbits;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a delay extent at this offset,
|
|
|
|
* it will be as a data.
|
|
|
|
*/
|
2013-02-18 05:27:26 +00:00
|
|
|
ext4_es_find_delayed_extent(inode, last, &es);
|
2013-02-18 05:26:51 +00:00
|
|
|
if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
|
2012-11-09 02:57:40 +00:00
|
|
|
if (last != start)
|
|
|
|
dataoff = last << blkbits;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a unwritten extent at this offset,
|
|
|
|
* it will be as a data or a hole according to page
|
|
|
|
* cache that has data or not.
|
|
|
|
*/
|
|
|
|
if (map.m_flags & EXT4_MAP_UNWRITTEN) {
|
|
|
|
int unwritten;
|
|
|
|
unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA,
|
|
|
|
&map, &dataoff);
|
|
|
|
if (unwritten)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
last++;
|
|
|
|
dataoff = last << blkbits;
|
|
|
|
} while (last <= end);
|
|
|
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
|
|
|
if (dataoff > isize)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
if (dataoff < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
|
|
|
|
return -EINVAL;
|
|
|
|
if (dataoff > maxsize)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (dataoff != file->f_pos) {
|
|
|
|
file->f_pos = dataoff;
|
|
|
|
file->f_version = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dataoff;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ext4_seek_hole() retrieves the offset for SEEK_HOLE.
|
|
|
|
*/
|
|
|
|
static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct ext4_map_blocks map;
|
|
|
|
struct extent_status es;
|
|
|
|
ext4_lblk_t start, last, end;
|
|
|
|
loff_t holeoff, isize;
|
|
|
|
int blkbits;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
|
|
|
|
isize = i_size_read(inode);
|
|
|
|
if (offset >= isize) {
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
start = offset >> blkbits;
|
|
|
|
last = start;
|
|
|
|
end = isize >> blkbits;
|
|
|
|
holeoff = offset;
|
|
|
|
|
|
|
|
do {
|
|
|
|
map.m_lblk = last;
|
|
|
|
map.m_len = end - last + 1;
|
|
|
|
ret = ext4_map_blocks(NULL, inode, &map, 0);
|
|
|
|
if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
|
|
|
|
last += ret;
|
|
|
|
holeoff = last << blkbits;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a delay extent at this offset,
|
|
|
|
* we will skip this extent.
|
|
|
|
*/
|
2013-02-18 05:27:26 +00:00
|
|
|
ext4_es_find_delayed_extent(inode, last, &es);
|
2013-02-18 05:26:51 +00:00
|
|
|
if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
|
|
|
|
last = es.es_lblk + es.es_len;
|
2012-11-09 02:57:40 +00:00
|
|
|
holeoff = last << blkbits;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a unwritten extent at this offset,
|
|
|
|
* it will be as a data or a hole according to page
|
|
|
|
* cache that has data or not.
|
|
|
|
*/
|
|
|
|
if (map.m_flags & EXT4_MAP_UNWRITTEN) {
|
|
|
|
int unwritten;
|
|
|
|
unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
|
|
|
|
&map, &holeoff);
|
|
|
|
if (!unwritten) {
|
|
|
|
last += ret;
|
|
|
|
holeoff = last << blkbits;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find a hole */
|
|
|
|
break;
|
|
|
|
} while (last <= end);
|
|
|
|
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
|
|
|
|
if (holeoff > isize)
|
|
|
|
holeoff = isize;
|
|
|
|
|
|
|
|
if (holeoff < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
|
|
|
|
return -EINVAL;
|
|
|
|
if (holeoff > maxsize)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (holeoff != file->f_pos) {
|
|
|
|
file->f_pos = holeoff;
|
|
|
|
file->f_version = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return holeoff;
|
|
|
|
}
|
|
|
|
|
2010-10-28 01:30:06 +00:00
|
|
|
/*
|
2012-04-30 18:14:03 +00: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-28 01:30:06 +00:00
|
|
|
*/
|
2012-12-17 23:59:39 +00:00
|
|
|
loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
|
2010-10-28 01:30:06 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2012-12-17 23:59:39 +00:00
|
|
|
switch (whence) {
|
2012-11-09 02:57:40 +00:00
|
|
|
case SEEK_SET:
|
|
|
|
case SEEK_CUR:
|
|
|
|
case SEEK_END:
|
2012-12-17 23:59:39 +00:00
|
|
|
return generic_file_llseek_size(file, offset, whence,
|
2012-11-09 02:57:40 +00:00
|
|
|
maxbytes, i_size_read(inode));
|
|
|
|
case SEEK_DATA:
|
|
|
|
return ext4_seek_data(file, offset, maxbytes);
|
|
|
|
case SEEK_HOLE:
|
|
|
|
return ext4_seek_hole(file, offset, maxbytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
2010-10-28 01:30:06 +00:00
|
|
|
}
|
|
|
|
|
2006-10-11 08:20:53 +00:00
|
|
|
const struct file_operations ext4_file_operations = {
|
2010-10-28 01:30:06 +00:00
|
|
|
.llseek = ext4_llseek,
|
2006-10-11 08:20:50 +00:00
|
|
|
.read = do_sync_read,
|
|
|
|
.write = do_sync_write,
|
|
|
|
.aio_read = generic_file_aio_read,
|
2006-10-11 08:20:53 +00:00
|
|
|
.aio_write = ext4_file_write,
|
2008-04-30 02:03:54 +00:00
|
|
|
.unlocked_ioctl = ext4_ioctl,
|
2006-10-11 08:20:50 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-10-11 08:20:53 +00:00
|
|
|
.compat_ioctl = ext4_compat_ioctl,
|
2006-10-11 08:20:50 +00:00
|
|
|
#endif
|
2008-07-11 23:27:31 +00:00
|
|
|
.mmap = ext4_file_mmap,
|
2009-06-13 14:09:48 +00:00
|
|
|
.open = ext4_file_open,
|
2006-10-11 08:20:53 +00:00
|
|
|
.release = ext4_release_file,
|
|
|
|
.fsync = ext4_sync_file,
|
2006-10-11 08:20:50 +00:00
|
|
|
.splice_read = generic_file_splice_read,
|
|
|
|
.splice_write = generic_file_splice_write,
|
2011-01-14 12:07:43 +00:00
|
|
|
.fallocate = ext4_fallocate,
|
2006-10-11 08:20:50 +00:00
|
|
|
};
|
|
|
|
|
2007-02-12 08:55:38 +00:00
|
|
|
const struct inode_operations ext4_file_inode_operations = {
|
2006-10-11 08:20:53 +00:00
|
|
|
.setattr = ext4_setattr,
|
2008-07-11 23:27:31 +00:00
|
|
|
.getattr = ext4_getattr,
|
2006-10-11 08:20:50 +00:00
|
|
|
.setxattr = generic_setxattr,
|
|
|
|
.getxattr = generic_getxattr,
|
2006-10-11 08:20:53 +00:00
|
|
|
.listxattr = ext4_listxattr,
|
2006-10-11 08:20:50 +00:00
|
|
|
.removexattr = generic_removexattr,
|
2011-07-23 15:37:31 +00:00
|
|
|
.get_acl = ext4_get_acl,
|
2008-10-07 04:46:36 +00:00
|
|
|
.fiemap = ext4_fiemap,
|
2006-10-11 08:20:50 +00:00
|
|
|
};
|
|
|
|
|