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>
|
2009-06-13 14:09:48 +00:00
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/path.h>
|
2015-09-08 21:58:40 +00:00
|
|
|
#include <linux/dax.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>
|
2015-02-22 16:58:50 +00:00
|
|
|
#include <linux/uio.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;
|
|
|
|
}
|
|
|
|
|
2014-05-12 14:50:23 +00:00
|
|
|
static 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
|
2014-04-17 20:09:22 +00:00
|
|
|
ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t 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
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
int blockmask = sb->s_blocksize - 1;
|
|
|
|
|
2014-04-12 16:45:25 +00:00
|
|
|
if (pos >= i_size_read(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
|
|
|
return 0;
|
|
|
|
|
2014-04-17 20:09:22 +00:00
|
|
|
if ((pos | iov_iter_alignment(from)) & blockmask)
|
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 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-11 08:20:50 +00:00
|
|
|
static ssize_t
|
2014-04-17 20:09:22 +00:00
|
|
|
ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
2006-10-11 08:20:50 +00:00
|
|
|
{
|
2014-04-21 18:26:57 +00:00
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
2015-04-09 17:52:01 +00:00
|
|
|
int o_direct = iocb->ki_flags & IOCB_DIRECT;
|
2016-03-09 03:44:50 +00:00
|
|
|
int unaligned_aio = 0;
|
2012-07-23 00:19:31 +00:00
|
|
|
int overwrite = 0;
|
2012-05-28 22:06:51 +00:00
|
|
|
ssize_t ret;
|
2014-04-21 18:26:28 +00:00
|
|
|
|
2016-03-09 03:44:50 +00:00
|
|
|
inode_lock(inode);
|
|
|
|
ret = generic_write_checks(iocb, from);
|
|
|
|
if (ret <= 0)
|
|
|
|
goto out;
|
|
|
|
|
2014-04-21 18:37:52 +00:00
|
|
|
/*
|
2016-03-09 03:44:50 +00:00
|
|
|
* Unaligned direct AIO must be serialized among each other as zeroing
|
|
|
|
* of partial blocks of two competing unaligned AIOs can result in data
|
|
|
|
* corruption.
|
2014-04-21 18:37:52 +00:00
|
|
|
*/
|
2016-03-09 03:44:50 +00:00
|
|
|
if (o_direct && ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
|
2014-04-21 18:37:52 +00:00
|
|
|
!is_sync_kiocb(iocb) &&
|
2016-03-09 03:44:50 +00:00
|
|
|
ext4_unaligned_aio(inode, from, iocb->ki_pos)) {
|
|
|
|
unaligned_aio = 1;
|
2014-04-21 18:37:52 +00:00
|
|
|
ext4_unwritten_wait(inode);
|
|
|
|
}
|
|
|
|
|
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);
|
2006-10-11 08:20:50 +00:00
|
|
|
|
2015-04-09 16:55:47 +00:00
|
|
|
if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) {
|
2014-04-21 18:37:52 +00:00
|
|
|
ret = -EFBIG;
|
2015-04-07 18:48:22 +00:00
|
|
|
goto out;
|
2014-04-21 18:37:52 +00:00
|
|
|
}
|
2015-04-09 16:55:47 +00:00
|
|
|
iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);
|
2008-01-29 04:58:27 +00:00
|
|
|
}
|
|
|
|
|
2014-10-30 14:53:16 +00:00
|
|
|
iocb->private = &overwrite;
|
2014-04-21 18:36:30 +00:00
|
|
|
if (o_direct) {
|
2015-04-09 16:55:47 +00:00
|
|
|
size_t length = iov_iter_count(from);
|
|
|
|
loff_t pos = iocb->ki_pos;
|
2014-04-21 18:26:57 +00:00
|
|
|
|
|
|
|
/* check whether we do a DIO overwrite or not */
|
2016-03-09 03:44:50 +00:00
|
|
|
if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
|
2016-09-30 05:55:32 +00:00
|
|
|
pos + length <= i_size_read(inode)) {
|
2014-04-21 18:26:57 +00:00
|
|
|
struct ext4_map_blocks map;
|
|
|
|
unsigned int blkbits = inode->i_blkbits;
|
|
|
|
int err, len;
|
|
|
|
|
|
|
|
map.m_lblk = pos >> blkbits;
|
2016-09-15 15:55:01 +00:00
|
|
|
map.m_len = EXT4_MAX_BLOCKS(length, pos, blkbits);
|
2014-04-21 18:26:57 +00:00
|
|
|
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
|
|
|
|
* unwritten 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;
|
|
|
|
}
|
2014-04-21 18:37:52 +00:00
|
|
|
}
|
2014-04-21 18:26:28 +00:00
|
|
|
|
2014-04-17 20:09:22 +00:00
|
|
|
ret = __generic_file_write_iter(iocb, from);
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(inode);
|
2014-04-21 18:26:28 +00:00
|
|
|
|
2016-04-07 15:52:01 +00:00
|
|
|
if (ret > 0)
|
|
|
|
ret = generic_write_sync(iocb, ret);
|
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
|
|
|
|
2015-04-07 18:48:22 +00:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
out:
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(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
|
|
|
return ret;
|
2006-10-11 08:20:50 +00:00
|
|
|
}
|
|
|
|
|
2015-02-16 23:59:38 +00:00
|
|
|
#ifdef CONFIG_FS_DAX
|
|
|
|
static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|
|
|
|
{
|
2015-09-08 21:59:22 +00:00
|
|
|
int result;
|
|
|
|
handle_t *handle = NULL;
|
2015-12-07 19:28:03 +00:00
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
|
|
|
struct super_block *sb = inode->i_sb;
|
2015-09-08 21:59:22 +00:00
|
|
|
bool write = vmf->flags & FAULT_FLAG_WRITE;
|
|
|
|
|
|
|
|
if (write) {
|
|
|
|
sb_start_pagefault(sb);
|
|
|
|
file_update_time(vma->vm_file);
|
2015-12-07 19:28:03 +00:00
|
|
|
down_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
|
|
|
|
EXT4_DATA_TRANS_BLOCKS(sb));
|
2015-12-07 19:28:03 +00:00
|
|
|
} else
|
|
|
|
down_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
|
|
|
|
if (IS_ERR(handle))
|
|
|
|
result = VM_FAULT_SIGBUS;
|
|
|
|
else
|
2016-07-26 22:21:05 +00:00
|
|
|
result = dax_fault(vma, vmf, ext4_dax_get_block);
|
2015-09-08 21:59:22 +00:00
|
|
|
|
|
|
|
if (write) {
|
|
|
|
if (!IS_ERR(handle))
|
|
|
|
ext4_journal_stop(handle);
|
2015-12-07 19:28:03 +00:00
|
|
|
up_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
sb_end_pagefault(sb);
|
2015-12-07 19:28:03 +00:00
|
|
|
} else
|
|
|
|
up_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
|
|
|
|
return result;
|
2015-02-16 23:59:38 +00:00
|
|
|
}
|
|
|
|
|
2015-09-08 21:59:03 +00:00
|
|
|
static int ext4_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,
|
|
|
|
pmd_t *pmd, unsigned int flags)
|
|
|
|
{
|
2015-09-08 21:59:22 +00:00
|
|
|
int result;
|
|
|
|
handle_t *handle = NULL;
|
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
bool write = flags & FAULT_FLAG_WRITE;
|
|
|
|
|
|
|
|
if (write) {
|
|
|
|
sb_start_pagefault(sb);
|
|
|
|
file_update_time(vma->vm_file);
|
2015-12-07 19:28:03 +00:00
|
|
|
down_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
|
|
|
|
ext4_chunk_trans_blocks(inode,
|
|
|
|
PMD_SIZE / PAGE_SIZE));
|
2015-12-07 19:28:03 +00:00
|
|
|
} else
|
|
|
|
down_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
|
|
|
|
if (IS_ERR(handle))
|
|
|
|
result = VM_FAULT_SIGBUS;
|
|
|
|
else
|
2016-07-26 22:21:05 +00:00
|
|
|
result = dax_pmd_fault(vma, addr, pmd, flags,
|
2016-05-11 09:58:48 +00:00
|
|
|
ext4_dax_get_block);
|
2015-09-08 21:59:22 +00:00
|
|
|
|
|
|
|
if (write) {
|
|
|
|
if (!IS_ERR(handle))
|
|
|
|
ext4_journal_stop(handle);
|
2015-12-07 19:28:03 +00:00
|
|
|
up_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
sb_end_pagefault(sb);
|
2015-12-07 19:28:03 +00:00
|
|
|
} else
|
|
|
|
up_read(&EXT4_I(inode)->i_mmap_sem);
|
2015-09-08 21:59:22 +00:00
|
|
|
|
|
|
|
return result;
|
2015-09-08 21:59:03 +00:00
|
|
|
}
|
|
|
|
|
2015-12-07 19:28:03 +00:00
|
|
|
/*
|
2016-02-27 19:01:13 +00:00
|
|
|
* Handle write fault for VM_MIXEDMAP mappings. Similarly to ext4_dax_fault()
|
2015-12-07 19:28:03 +00:00
|
|
|
* handler we check for races agaist truncate. Note that since we cycle through
|
|
|
|
* i_mmap_sem, we are sure that also any hole punching that began before we
|
|
|
|
* were called is finished by now and so if it included part of the file we
|
|
|
|
* are working on, our pte will get unmapped and the check for pte_same() in
|
|
|
|
* wp_pfn_shared() fails. Thus fault gets retried and things work out as
|
|
|
|
* desired.
|
|
|
|
*/
|
|
|
|
static int ext4_dax_pfn_mkwrite(struct vm_area_struct *vma,
|
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
loff_t size;
|
2016-01-22 23:10:53 +00:00
|
|
|
int ret;
|
2015-12-07 19:28:03 +00:00
|
|
|
|
|
|
|
sb_start_pagefault(sb);
|
|
|
|
file_update_time(vma->vm_file);
|
|
|
|
down_read(&EXT4_I(inode)->i_mmap_sem);
|
|
|
|
size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
|
|
|
if (vmf->pgoff >= size)
|
|
|
|
ret = VM_FAULT_SIGBUS;
|
2016-01-22 23:10:53 +00:00
|
|
|
else
|
|
|
|
ret = dax_pfn_mkwrite(vma, vmf);
|
2015-12-07 19:28:03 +00:00
|
|
|
up_read(&EXT4_I(inode)->i_mmap_sem);
|
|
|
|
sb_end_pagefault(sb);
|
|
|
|
|
|
|
|
return ret;
|
2015-02-16 23:59:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct vm_operations_struct ext4_dax_vm_ops = {
|
|
|
|
.fault = ext4_dax_fault,
|
2015-09-08 21:59:03 +00:00
|
|
|
.pmd_fault = ext4_dax_pmd_fault,
|
2016-02-27 19:01:13 +00:00
|
|
|
.page_mkwrite = ext4_dax_fault,
|
2015-12-07 19:28:03 +00:00
|
|
|
.pfn_mkwrite = ext4_dax_pfn_mkwrite,
|
2015-02-16 23:59:38 +00:00
|
|
|
};
|
|
|
|
#else
|
|
|
|
#define ext4_dax_vm_ops ext4_file_vm_ops
|
|
|
|
#endif
|
|
|
|
|
2009-09-27 18:29:37 +00:00
|
|
|
static const struct vm_operations_struct ext4_file_vm_ops = {
|
2015-12-07 19:28:03 +00:00
|
|
|
.fault = ext4_filemap_fault,
|
2014-04-07 22:37:19 +00:00
|
|
|
.map_pages = filemap_map_pages,
|
2008-07-11 23:27:31 +00:00
|
|
|
.page_mkwrite = ext4_page_mkwrite,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
|
{
|
2015-04-12 04:56:10 +00:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
|
|
|
|
if (ext4_encrypted_inode(inode)) {
|
2016-07-10 18:01:03 +00:00
|
|
|
int err = fscrypt_get_encryption_info(inode);
|
2015-04-12 04:56:10 +00:00
|
|
|
if (err)
|
|
|
|
return 0;
|
2016-07-10 18:01:03 +00:00
|
|
|
if (!fscrypt_has_encryption_key(inode))
|
2015-05-31 17:35:39 +00:00
|
|
|
return -ENOKEY;
|
2015-04-12 04:56:10 +00:00
|
|
|
}
|
2008-07-11 23:27:31 +00:00
|
|
|
file_accessed(file);
|
2015-02-16 23:59:38 +00:00
|
|
|
if (IS_DAX(file_inode(file))) {
|
|
|
|
vma->vm_ops = &ext4_dax_vm_ops;
|
2015-09-08 21:59:03 +00:00
|
|
|
vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
|
2015-02-16 23:59:38 +00:00
|
|
|
} else {
|
|
|
|
vma->vm_ops = &ext4_file_vm_ops;
|
|
|
|
}
|
2008-07-11 23:27:31 +00:00
|
|
|
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);
|
|
|
|
struct vfsmount *mnt = filp->f_path.mnt;
|
2016-03-26 20:14:41 +00:00
|
|
|
struct dentry *dir;
|
2009-06-13 14:09:48 +00:00
|
|
|
struct path path;
|
|
|
|
char buf[64], *cp;
|
2015-04-12 04:56:10 +00:00
|
|
|
int ret;
|
2009-06-13 14:09:48 +00:00
|
|
|
|
|
|
|
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);
|
2014-05-13 02:06:43 +00:00
|
|
|
BUFFER_TRACE(sbi->s_sbh, "get_write_access");
|
2012-07-23 00:31:31 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
2015-05-31 17:35:39 +00:00
|
|
|
if (ext4_encrypted_inode(inode)) {
|
2016-07-10 18:01:03 +00:00
|
|
|
ret = fscrypt_get_encryption_info(inode);
|
2015-05-31 17:35:39 +00:00
|
|
|
if (ret)
|
|
|
|
return -EACCES;
|
2016-07-10 18:01:03 +00:00
|
|
|
if (!fscrypt_has_encryption_key(inode))
|
2015-05-31 17:35:39 +00:00
|
|
|
return -ENOKEY;
|
|
|
|
}
|
2016-03-26 20:14:41 +00:00
|
|
|
|
2016-03-26 20:14:42 +00:00
|
|
|
dir = dget_parent(file_dentry(filp));
|
2016-03-26 20:14:41 +00:00
|
|
|
if (ext4_encrypted_inode(d_inode(dir)) &&
|
2016-07-10 18:01:03 +00:00
|
|
|
!fscrypt_has_permitted_context(d_inode(dir), inode)) {
|
2016-02-08 05:54:26 +00:00
|
|
|
ext4_warning(inode->i_sb,
|
2016-04-27 05:11:21 +00:00
|
|
|
"Inconsistent encryption contexts: %lu/%lu",
|
2016-03-26 20:14:41 +00:00
|
|
|
(unsigned long) d_inode(dir)->i_ino,
|
2016-02-08 05:54:26 +00:00
|
|
|
(unsigned long) inode->i_ino);
|
2016-03-26 20:14:41 +00:00
|
|
|
dput(dir);
|
2016-02-08 05:54:26 +00:00
|
|
|
return -EPERM;
|
|
|
|
}
|
2016-03-26 20:14:41 +00:00
|
|
|
dput(dir);
|
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
|
|
|
|
*/
|
2013-08-17 01:19:41 +00:00
|
|
|
if (filp->f_mode & FMODE_WRITE) {
|
2015-04-12 04:56:10 +00:00
|
|
|
ret = ext4_inode_attach_jinode(inode);
|
2013-08-17 01:19:41 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-01-10 17:29:43 +00:00
|
|
|
}
|
2015-05-31 17:35:39 +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.
|
|
|
|
*/
|
2015-01-02 20:16:00 +00:00
|
|
|
static int ext4_find_unwritten_pgoff(struct inode *inode,
|
|
|
|
int whence,
|
2016-03-10 04:11:13 +00:00
|
|
|
ext4_lblk_t end_blk,
|
2015-01-02 20:16:00 +00:00
|
|
|
loff_t *offset)
|
2012-11-09 02:57:40 +00:00
|
|
|
{
|
|
|
|
struct pagevec pvec;
|
2015-01-02 20:16:00 +00:00
|
|
|
unsigned int blkbits;
|
2012-11-09 02:57:40 +00:00
|
|
|
pgoff_t index;
|
|
|
|
pgoff_t end;
|
2015-01-02 20:16:00 +00:00
|
|
|
loff_t endoff;
|
2012-11-09 02:57:40 +00:00
|
|
|
loff_t startoff;
|
|
|
|
loff_t lastoff;
|
|
|
|
int found = 0;
|
|
|
|
|
2015-01-02 20:16:00 +00:00
|
|
|
blkbits = inode->i_sb->s_blocksize_bits;
|
2012-11-09 02:57:40 +00:00
|
|
|
startoff = *offset;
|
|
|
|
lastoff = startoff;
|
2016-03-10 04:11:13 +00:00
|
|
|
endoff = (loff_t)end_blk << blkbits;
|
2012-11-09 02:57:40 +00:00
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
index = startoff >> PAGE_SHIFT;
|
|
|
|
end = endoff >> PAGE_SHIFT;
|
2012-11-09 02:57:40 +00:00
|
|
|
|
|
|
|
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;
|
2015-01-02 20:16:00 +00:00
|
|
|
struct extent_status es;
|
|
|
|
ext4_lblk_t start, last, end;
|
|
|
|
loff_t dataoff, isize;
|
|
|
|
int blkbits;
|
2016-03-10 04:11:13 +00:00
|
|
|
int ret;
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_lock(inode);
|
2015-01-02 20:16:00 +00:00
|
|
|
|
|
|
|
isize = i_size_read(inode);
|
|
|
|
if (offset >= isize) {
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(inode);
|
2012-11-09 02:57:40 +00:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
2015-01-02 20:16:00 +00:00
|
|
|
|
|
|
|
blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
start = offset >> blkbits;
|
|
|
|
last = start;
|
|
|
|
end = isize >> blkbits;
|
|
|
|
dataoff = offset;
|
|
|
|
|
|
|
|
do {
|
2016-03-10 04:11:13 +00:00
|
|
|
ret = ext4_get_next_extent(inode, last, end - last + 1, &es);
|
|
|
|
if (ret <= 0) {
|
|
|
|
/* No extent found -> no data */
|
|
|
|
if (ret == 0)
|
|
|
|
ret = -ENXIO;
|
|
|
|
inode_unlock(inode);
|
|
|
|
return ret;
|
2015-01-02 20:16:00 +00:00
|
|
|
}
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2016-03-10 04:11:13 +00:00
|
|
|
last = es.es_lblk;
|
|
|
|
if (last != start)
|
|
|
|
dataoff = (loff_t)last << blkbits;
|
|
|
|
if (!ext4_es_is_unwritten(&es))
|
2012-11-09 02:57:40 +00:00
|
|
|
break;
|
|
|
|
|
2015-01-02 20:16:00 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2016-03-10 04:11:13 +00:00
|
|
|
if (ext4_find_unwritten_pgoff(inode, SEEK_DATA,
|
|
|
|
es.es_lblk + es.es_len, &dataoff))
|
|
|
|
break;
|
|
|
|
last += es.es_len;
|
2015-01-02 20:16:00 +00:00
|
|
|
dataoff = (loff_t)last << blkbits;
|
2016-03-10 04:11:13 +00:00
|
|
|
cond_resched();
|
2015-01-02 20:16:00 +00:00
|
|
|
} while (last <= end);
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(inode);
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2015-01-02 20:16:00 +00:00
|
|
|
if (dataoff > isize)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
return vfs_setpos(file, dataoff, maxsize);
|
2012-11-09 02:57:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-01-02 20:16:00 +00:00
|
|
|
* ext4_seek_hole() retrieves the offset for SEEK_HOLE.
|
2012-11-09 02:57:40 +00:00
|
|
|
*/
|
|
|
|
static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
2015-01-02 20:16:00 +00:00
|
|
|
struct extent_status es;
|
|
|
|
ext4_lblk_t start, last, end;
|
|
|
|
loff_t holeoff, isize;
|
|
|
|
int blkbits;
|
2016-03-10 04:11:13 +00:00
|
|
|
int ret;
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_lock(inode);
|
2015-01-02 20:16:00 +00:00
|
|
|
|
|
|
|
isize = i_size_read(inode);
|
|
|
|
if (offset >= isize) {
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(inode);
|
2012-11-09 02:57:40 +00:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
2015-01-02 20:16:00 +00:00
|
|
|
blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
start = offset >> blkbits;
|
|
|
|
last = start;
|
|
|
|
end = isize >> blkbits;
|
|
|
|
holeoff = offset;
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2015-01-02 20:16:00 +00:00
|
|
|
do {
|
2016-03-10 04:11:13 +00:00
|
|
|
ret = ext4_get_next_extent(inode, last, end - last + 1, &es);
|
|
|
|
if (ret < 0) {
|
|
|
|
inode_unlock(inode);
|
|
|
|
return ret;
|
2015-01-02 20:16:00 +00:00
|
|
|
}
|
2016-03-10 04:11:13 +00:00
|
|
|
/* Found a hole? */
|
|
|
|
if (ret == 0 || es.es_lblk > last) {
|
|
|
|
if (last != start)
|
|
|
|
holeoff = (loff_t)last << blkbits;
|
|
|
|
break;
|
2015-01-02 20:16:00 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2016-03-10 04:11:13 +00:00
|
|
|
if (ext4_es_is_unwritten(&es) &&
|
|
|
|
ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
|
|
|
|
last + es.es_len, &holeoff))
|
|
|
|
break;
|
2015-01-02 20:16:00 +00:00
|
|
|
|
2016-03-10 04:11:13 +00:00
|
|
|
last += es.es_len;
|
|
|
|
holeoff = (loff_t)last << blkbits;
|
|
|
|
cond_resched();
|
2015-01-02 20:16:00 +00:00
|
|
|
} while (last <= end);
|
|
|
|
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(inode);
|
2012-11-09 02:57:40 +00:00
|
|
|
|
2015-01-02 20:16:00 +00:00
|
|
|
if (holeoff > isize)
|
|
|
|
holeoff = isize;
|
|
|
|
|
|
|
|
return vfs_setpos(file, holeoff, maxsize);
|
2012-11-09 02:57:40 +00:00
|
|
|
}
|
|
|
|
|
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,
|
2014-04-02 18:33:16 +00:00
|
|
|
.read_iter = generic_file_read_iter,
|
2014-04-17 20:09:22 +00:00
|
|
|
.write_iter = ext4_file_write_iter,
|
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,
|
2016-10-07 23:59:59 +00:00
|
|
|
.get_unmapped_area = thp_get_unmapped_area,
|
2006-10-11 08:20:50 +00:00
|
|
|
.splice_read = generic_file_splice_read,
|
2014-04-05 08:27:08 +00:00
|
|
|
.splice_write = iter_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:53 +00:00
|
|
|
.listxattr = ext4_listxattr,
|
2011-07-23 15:37:31 +00:00
|
|
|
.get_acl = ext4_get_acl,
|
2013-12-20 13:16:44 +00:00
|
|
|
.set_acl = ext4_set_acl,
|
2008-10-07 04:46:36 +00:00
|
|
|
.fiemap = ext4_fiemap,
|
2006-10-11 08:20:50 +00:00
|
|
|
};
|
|
|
|
|