Commit ad7fefb1 authored by Theodore Ts'o's avatar Theodore Ts'o

Revert "ext4: fix suboptimal seek_{data,hole} extents traversial"

This reverts commit 14516bb7.

This was causing regression test failures with generic/285 with an ext3
filesystem using CONFIG_EXT4_USE_FOR_EXT23.
Signed-off-by: default avatarTheodore Ts'o <tytso@mit.edu>
parent 011fa994
...@@ -5166,8 +5166,8 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, ...@@ -5166,8 +5166,8 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
/* fallback to generic here if not in extents fmt */ /* fallback to generic here if not in extents fmt */
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
return __generic_block_fiemap(inode, fieinfo, start, len, return generic_block_fiemap(inode, fieinfo, start, len,
ext4_get_block); ext4_get_block);
if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS)) if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS))
return -EBADR; return -EBADR;
......
...@@ -273,19 +273,24 @@ static int ext4_file_open(struct inode * inode, struct file * filp) ...@@ -273,19 +273,24 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
* we determine this extent as a data or a hole according to whether the * we determine this extent as a data or a hole according to whether the
* page cache has data or not. * page cache has data or not.
*/ */
static int ext4_find_unwritten_pgoff(struct inode *inode, int whence, static int ext4_find_unwritten_pgoff(struct inode *inode,
loff_t endoff, loff_t *offset) int whence,
struct ext4_map_blocks *map,
loff_t *offset)
{ {
struct pagevec pvec; struct pagevec pvec;
unsigned int blkbits;
pgoff_t index; pgoff_t index;
pgoff_t end; pgoff_t end;
loff_t endoff;
loff_t startoff; loff_t startoff;
loff_t lastoff; loff_t lastoff;
int found = 0; int found = 0;
blkbits = inode->i_sb->s_blocksize_bits;
startoff = *offset; startoff = *offset;
lastoff = startoff; lastoff = startoff;
endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits;
index = startoff >> PAGE_CACHE_SHIFT; index = startoff >> PAGE_CACHE_SHIFT;
end = endoff >> PAGE_CACHE_SHIFT; end = endoff >> PAGE_CACHE_SHIFT;
...@@ -403,144 +408,147 @@ static int ext4_find_unwritten_pgoff(struct inode *inode, int whence, ...@@ -403,144 +408,147 @@ static int ext4_find_unwritten_pgoff(struct inode *inode, int whence,
static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize) static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
{ {
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct fiemap_extent_info fie; struct ext4_map_blocks map;
struct fiemap_extent ext[2]; struct extent_status es;
loff_t next; ext4_lblk_t start, last, end;
int i, ret = 0; loff_t dataoff, isize;
int blkbits;
int ret = 0;
mutex_lock(&inode->i_mutex); mutex_lock(&inode->i_mutex);
if (offset >= inode->i_size) {
isize = i_size_read(inode);
if (offset >= isize) {
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return -ENXIO; return -ENXIO;
} }
fie.fi_flags = 0;
fie.fi_extents_max = 2; blkbits = inode->i_sb->s_blocksize_bits;
fie.fi_extents_start = (struct fiemap_extent __user *) &ext; start = offset >> blkbits;
while (1) { last = start;
mm_segment_t old_fs = get_fs(); end = isize >> blkbits;
dataoff = offset;
fie.fi_extents_mapped = 0;
memset(ext, 0, sizeof(*ext) * fie.fi_extents_max); do {
map.m_lblk = last;
set_fs(get_ds()); map.m_len = end - last + 1;
ret = ext4_fiemap(inode, &fie, offset, maxsize - offset); ret = ext4_map_blocks(NULL, inode, &map, 0);
set_fs(old_fs); if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
if (ret) if (last != start)
dataoff = (loff_t)last << blkbits;
break; break;
}
/* No extents found, EOF */ /*
if (!fie.fi_extents_mapped) { * If there is a delay extent at this offset,
ret = -ENXIO; * it will be as a data.
*/
ext4_es_find_delayed_extent_range(inode, last, last, &es);
if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
if (last != start)
dataoff = (loff_t)last << blkbits;
break; break;
} }
for (i = 0; i < fie.fi_extents_mapped; i++) {
next = (loff_t)(ext[i].fe_length + ext[i].fe_logical);
if (offset < (loff_t)ext[i].fe_logical) /*
offset = (loff_t)ext[i].fe_logical; * If there is a unwritten extent at this offset,
/* * it will be as a data or a hole according to page
* If extent is not unwritten, then it contains valid * cache that has data or not.
* data, mapped or delayed. */
*/ if (map.m_flags & EXT4_MAP_UNWRITTEN) {
if (!(ext[i].fe_flags & FIEMAP_EXTENT_UNWRITTEN)) int unwritten;
goto out; unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA,
&map, &dataoff);
if (unwritten)
break;
}
/* last++;
* If there is a unwritten extent at this offset, dataoff = (loff_t)last << blkbits;
* it will be as a data or a hole according to page } while (last <= end);
* cache that has data or not.
*/
if (ext4_find_unwritten_pgoff(inode, SEEK_DATA,
next, &offset))
goto out;
if (ext[i].fe_flags & FIEMAP_EXTENT_LAST) {
ret = -ENXIO;
goto out;
}
offset = next;
}
}
if (offset > inode->i_size)
offset = inode->i_size;
out:
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
if (ret)
return ret;
return vfs_setpos(file, offset, maxsize); if (dataoff > isize)
return -ENXIO;
return vfs_setpos(file, dataoff, maxsize);
} }
/* /*
* ext4_seek_hole() retrieves the offset for SEEK_HOLE * ext4_seek_hole() retrieves the offset for SEEK_HOLE.
*/ */
static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize) static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
{ {
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct fiemap_extent_info fie; struct ext4_map_blocks map;
struct fiemap_extent ext[2]; struct extent_status es;
loff_t next; ext4_lblk_t start, last, end;
int i, ret = 0; loff_t holeoff, isize;
int blkbits;
int ret = 0;
mutex_lock(&inode->i_mutex); mutex_lock(&inode->i_mutex);
if (offset >= inode->i_size) {
isize = i_size_read(inode);
if (offset >= isize) {
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return -ENXIO; return -ENXIO;
} }
fie.fi_flags = 0; blkbits = inode->i_sb->s_blocksize_bits;
fie.fi_extents_max = 2; start = offset >> blkbits;
fie.fi_extents_start = (struct fiemap_extent __user *)&ext; last = start;
while (1) { end = isize >> blkbits;
mm_segment_t old_fs = get_fs(); holeoff = offset;
fie.fi_extents_mapped = 0;
memset(ext, 0, sizeof(*ext));
set_fs(get_ds()); do {
ret = ext4_fiemap(inode, &fie, offset, maxsize - offset); map.m_lblk = last;
set_fs(old_fs); map.m_len = end - last + 1;
if (ret) ret = ext4_map_blocks(NULL, inode, &map, 0);
break; if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
last += ret;
holeoff = (loff_t)last << blkbits;
continue;
}
/* No extents found */ /*
if (!fie.fi_extents_mapped) * If there is a delay extent at this offset,
break; * we will skip this extent.
*/
ext4_es_find_delayed_extent_range(inode, last, last, &es);
if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
last = es.es_lblk + es.es_len;
holeoff = (loff_t)last << blkbits;
continue;
}
for (i = 0; i < fie.fi_extents_mapped; i++) { /*
next = (loff_t)(ext[i].fe_logical + ext[i].fe_length); * If there is a unwritten extent at this offset,
/* * it will be as a data or a hole according to page
* If extent is not unwritten, then it contains valid * cache that has data or not.
* data, mapped or delayed. */
*/ if (map.m_flags & EXT4_MAP_UNWRITTEN) {
if (!(ext[i].fe_flags & FIEMAP_EXTENT_UNWRITTEN)) { int unwritten;
if (offset < (loff_t)ext[i].fe_logical) unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
goto out; &map, &holeoff);
offset = next; if (!unwritten) {
last += ret;
holeoff = (loff_t)last << blkbits;
continue; 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 (ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
next, &offset))
goto out;
offset = next;
if (ext[i].fe_flags & FIEMAP_EXTENT_LAST)
goto out;
} }
}
if (offset > inode->i_size) /* find a hole */
offset = inode->i_size; break;
out: } while (last <= end);
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
if (ret)
return ret;
return vfs_setpos(file, offset, maxsize); if (holeoff > isize)
holeoff = isize;
return vfs_setpos(file, holeoff, maxsize);
} }
/* /*
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment