|
|
@@ -3566,20 +3566,190 @@ int ext4_can_truncate(struct inode *inode)
|
|
|
int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
|
|
|
{
|
|
|
struct inode *inode = file_inode(file);
|
|
|
+ struct super_block *sb = inode->i_sb;
|
|
|
+ ext4_lblk_t first_block, stop_block;
|
|
|
+ struct address_space *mapping = inode->i_mapping;
|
|
|
+ loff_t first_page, last_page, page_len;
|
|
|
+ loff_t first_page_offset, last_page_offset;
|
|
|
+ handle_t *handle;
|
|
|
+ unsigned int credits;
|
|
|
+ int ret = 0;
|
|
|
+
|
|
|
if (!S_ISREG(inode->i_mode))
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
- if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
|
|
|
- return ext4_ind_punch_hole(file, offset, length);
|
|
|
-
|
|
|
- if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
|
|
|
+ if (EXT4_SB(sb)->s_cluster_ratio > 1) {
|
|
|
/* TODO: Add support for bigalloc file systems */
|
|
|
return -EOPNOTSUPP;
|
|
|
}
|
|
|
|
|
|
trace_ext4_punch_hole(inode, offset, length);
|
|
|
|
|
|
- return ext4_ext_punch_hole(file, offset, length);
|
|
|
+ /*
|
|
|
+ * Write out all dirty pages to avoid race conditions
|
|
|
+ * Then release them.
|
|
|
+ */
|
|
|
+ if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
|
|
|
+ ret = filemap_write_and_wait_range(mapping, offset,
|
|
|
+ offset + length - 1);
|
|
|
+ if (ret)
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ mutex_lock(&inode->i_mutex);
|
|
|
+ /* It's not possible punch hole on append only file */
|
|
|
+ if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) {
|
|
|
+ ret = -EPERM;
|
|
|
+ goto out_mutex;
|
|
|
+ }
|
|
|
+ if (IS_SWAPFILE(inode)) {
|
|
|
+ ret = -ETXTBSY;
|
|
|
+ goto out_mutex;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* No need to punch hole beyond i_size */
|
|
|
+ if (offset >= inode->i_size)
|
|
|
+ goto out_mutex;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * If the hole extends beyond i_size, set the hole
|
|
|
+ * to end after the page that contains i_size
|
|
|
+ */
|
|
|
+ if (offset + length > inode->i_size) {
|
|
|
+ length = inode->i_size +
|
|
|
+ PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) -
|
|
|
+ offset;
|
|
|
+ }
|
|
|
+
|
|
|
+ first_page = (offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
|
|
|
+ last_page = (offset + length) >> PAGE_CACHE_SHIFT;
|
|
|
+
|
|
|
+ first_page_offset = first_page << PAGE_CACHE_SHIFT;
|
|
|
+ last_page_offset = last_page << PAGE_CACHE_SHIFT;
|
|
|
+
|
|
|
+ /* Now release the pages */
|
|
|
+ if (last_page_offset > first_page_offset) {
|
|
|
+ truncate_pagecache_range(inode, first_page_offset,
|
|
|
+ last_page_offset - 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Wait all existing dio workers, newcomers will block on i_mutex */
|
|
|
+ ext4_inode_block_unlocked_dio(inode);
|
|
|
+ ret = ext4_flush_unwritten_io(inode);
|
|
|
+ if (ret)
|
|
|
+ goto out_dio;
|
|
|
+ inode_dio_wait(inode);
|
|
|
+
|
|
|
+ if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
|
|
|
+ credits = ext4_writepage_trans_blocks(inode);
|
|
|
+ else
|
|
|
+ credits = ext4_blocks_for_truncate(inode);
|
|
|
+ handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
|
|
|
+ if (IS_ERR(handle)) {
|
|
|
+ ret = PTR_ERR(handle);
|
|
|
+ ext4_std_error(sb, ret);
|
|
|
+ goto out_dio;
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Now we need to zero out the non-page-aligned data in the
|
|
|
+ * pages at the start and tail of the hole, and unmap the
|
|
|
+ * buffer heads for the block aligned regions of the page that
|
|
|
+ * were completely zeroed.
|
|
|
+ */
|
|
|
+ if (first_page > last_page) {
|
|
|
+ /*
|
|
|
+ * If the file space being truncated is contained
|
|
|
+ * within a page just zero out and unmap the middle of
|
|
|
+ * that page
|
|
|
+ */
|
|
|
+ ret = ext4_discard_partial_page_buffers(handle,
|
|
|
+ mapping, offset, length, 0);
|
|
|
+
|
|
|
+ if (ret)
|
|
|
+ goto out_stop;
|
|
|
+ } else {
|
|
|
+ /*
|
|
|
+ * zero out and unmap the partial page that contains
|
|
|
+ * the start of the hole
|
|
|
+ */
|
|
|
+ page_len = first_page_offset - offset;
|
|
|
+ if (page_len > 0) {
|
|
|
+ ret = ext4_discard_partial_page_buffers(handle, mapping,
|
|
|
+ offset, page_len, 0);
|
|
|
+ if (ret)
|
|
|
+ goto out_stop;
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * zero out and unmap the partial page that contains
|
|
|
+ * the end of the hole
|
|
|
+ */
|
|
|
+ page_len = offset + length - last_page_offset;
|
|
|
+ if (page_len > 0) {
|
|
|
+ ret = ext4_discard_partial_page_buffers(handle, mapping,
|
|
|
+ last_page_offset, page_len, 0);
|
|
|
+ if (ret)
|
|
|
+ goto out_stop;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * If i_size is contained in the last page, we need to
|
|
|
+ * unmap and zero the partial page after i_size
|
|
|
+ */
|
|
|
+ if (inode->i_size >> PAGE_CACHE_SHIFT == last_page &&
|
|
|
+ inode->i_size % PAGE_CACHE_SIZE != 0) {
|
|
|
+ page_len = PAGE_CACHE_SIZE -
|
|
|
+ (inode->i_size & (PAGE_CACHE_SIZE - 1));
|
|
|
+
|
|
|
+ if (page_len > 0) {
|
|
|
+ ret = ext4_discard_partial_page_buffers(handle,
|
|
|
+ mapping, inode->i_size, page_len, 0);
|
|
|
+
|
|
|
+ if (ret)
|
|
|
+ goto out_stop;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ first_block = (offset + sb->s_blocksize - 1) >>
|
|
|
+ EXT4_BLOCK_SIZE_BITS(sb);
|
|
|
+ stop_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb);
|
|
|
+
|
|
|
+ /* If there are no blocks to remove, return now */
|
|
|
+ if (first_block >= stop_block)
|
|
|
+ goto out_stop;
|
|
|
+
|
|
|
+ down_write(&EXT4_I(inode)->i_data_sem);
|
|
|
+ ext4_discard_preallocations(inode);
|
|
|
+
|
|
|
+ ret = ext4_es_remove_extent(inode, first_block,
|
|
|
+ stop_block - first_block);
|
|
|
+ if (ret) {
|
|
|
+ up_write(&EXT4_I(inode)->i_data_sem);
|
|
|
+ goto out_stop;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
|
|
|
+ ret = ext4_ext_remove_space(inode, first_block,
|
|
|
+ stop_block - 1);
|
|
|
+ else
|
|
|
+ ret = ext4_free_hole_blocks(handle, inode, first_block,
|
|
|
+ stop_block);
|
|
|
+
|
|
|
+ ext4_discard_preallocations(inode);
|
|
|
+ if (IS_SYNC(inode))
|
|
|
+ ext4_handle_sync(handle);
|
|
|
+ up_write(&EXT4_I(inode)->i_data_sem);
|
|
|
+ inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
|
|
|
+ ext4_mark_inode_dirty(handle, inode);
|
|
|
+out_stop:
|
|
|
+ ext4_journal_stop(handle);
|
|
|
+out_dio:
|
|
|
+ ext4_inode_resume_unlocked_dio(inode);
|
|
|
+out_mutex:
|
|
|
+ mutex_unlock(&inode->i_mutex);
|
|
|
+ return ret;
|
|
|
}
|
|
|
|
|
|
/*
|
Theodore Ts'o