Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 (5439ca6b) · Commits · 戴 / test

fs/ext4/extents.c

+18 −4

Original line number	Diff line number	Diff line
		@@ -2226,13 +2226,14 @@ errout:
		* removes index from the index block.
		*/
		static int ext4_ext_rm_idx(handle_t handle, struct inode inode,
		struct ext4_ext_path *path)
		struct ext4_ext_path *path, int depth)
		{
		int err;
		ext4_fsblk_t leaf;

		/* free index block */
		path--;
		depth--;
		path = path + depth;
		leaf = ext4_idx_pblock(path->p_idx);
		if (unlikely(path->p_hdr->eh_entries == 0)) {
		EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
		@@ -2257,6 +2258,19 @@ static int ext4_ext_rm_idx(handle_t handle, struct inode inode,

		ext4_free_blocks(handle, inode, NULL, leaf, 1,
		EXT4_FREE_BLOCKS_METADATA \| EXT4_FREE_BLOCKS_FORGET);

		while (--depth >= 0) {
		if (path->p_idx != EXT_FIRST_INDEX(path->p_hdr))
		break;
		path--;
		err = ext4_ext_get_access(handle, inode, path);
		if (err)
		break;
		path->p_idx->ei_block = (path+1)->p_idx->ei_block;
		err = ext4_ext_dirty(handle, inode, path);
		if (err)
		break;
		}
		return err;
		}

		@@ -2599,7 +2613,7 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
		/* if this leaf is free, then we should
		* remove it from index block above */
		if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
		err = ext4_ext_rm_idx(handle, inode, path + depth);
		err = ext4_ext_rm_idx(handle, inode, path, depth);

		out:
		return err;
		@@ -2802,7 +2816,7 @@ again:
		/* index is empty, remove it;
		* handle must be already prepared by the
		* truncatei_leaf() */
		err = ext4_ext_rm_idx(handle, inode, path + i);
		err = ext4_ext_rm_idx(handle, inode, path, i);
		}
		/* root level has p_bh == NULL, brelse() eats this */
		brelse(path[i].p_bh);

fs/ext4/file.c

+0 −8

Original line number	Diff line number	Diff line
		@@ -108,14 +108,6 @@ ext4_file_dio_write(struct kiocb iocb, const struct iovec iov,

		/* Unaligned direct AIO must be serialized; see comment above */
		if (unaligned_aio) {
		static unsigned long unaligned_warn_time;

		/* Warn about this once per day */
		if (printk_timed_ratelimit(&unaligned_warn_time, 606024*HZ))
		ext4_msg(inode->i_sb, KERN_WARNING,
		"Unaligned AIO/DIO on inode %ld by %s; "
		"performance will be poor.",
		inode->i_ino, current->comm);
		mutex_lock(ext4_aio_mutex(inode));
		ext4_unwritten_wait(inode);
		}

fs/ext4/fsync.c

+0 −2

Original line number	Diff line number	Diff line
		@@ -109,8 +109,6 @@ static int __sync_inode(struct inode *inode, int datasync)
		*
		* What we do is just kick off a commit and wait on it. This will snapshot the
		* inode to disk.
		*
		* i_mutex lock is held when entering and exiting this function
		*/

		int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)

fs/ext4/inode.c

+84 −15

Original line number	Diff line number	Diff line
		@@ -2880,8 +2880,6 @@ static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offs

		static void ext4_invalidatepage(struct page *page, unsigned long offset)
		{
		journal_t *journal = EXT4_JOURNAL(page->mapping->host);

		trace_ext4_invalidatepage(page, offset);

		/*
		@@ -2889,16 +2887,34 @@ static void ext4_invalidatepage(struct page *page, unsigned long offset)
		*/
		if (ext4_should_dioread_nolock(page->mapping->host))
		ext4_invalidatepage_free_endio(page, offset);

		/* No journalling happens on data buffers when this function is used */
		WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));

		block_invalidatepage(page, offset);
		}

		static int __ext4_journalled_invalidatepage(struct page *page,
		unsigned long offset)
		{
		journal_t *journal = EXT4_JOURNAL(page->mapping->host);

		trace_ext4_journalled_invalidatepage(page, offset);

		/*
		* If it's a full truncate we just forget about the pending dirtying
		*/
		if (offset == 0)
		ClearPageChecked(page);

		if (journal)
		jbd2_journal_invalidatepage(journal, page, offset);
		else
		block_invalidatepage(page, offset);
		return jbd2_journal_invalidatepage(journal, page, offset);
		}

		/* Wrapper for aops... */
		static void ext4_journalled_invalidatepage(struct page *page,
		unsigned long offset)
		{
		WARN_ON(__ext4_journalled_invalidatepage(page, offset) < 0);
		}

		static int ext4_releasepage(struct page *page, gfp_t wait)
		@@ -3264,7 +3280,7 @@ static const struct address_space_operations ext4_journalled_aops = {
		.write_end = ext4_journalled_write_end,
		.set_page_dirty = ext4_journalled_set_page_dirty,
		.bmap = ext4_bmap,
		.invalidatepage = ext4_invalidatepage,
		.invalidatepage = ext4_journalled_invalidatepage,
		.releasepage = ext4_releasepage,
		.direct_IO = ext4_direct_IO,
		.is_partially_uptodate = block_is_partially_uptodate,
		@@ -4304,6 +4320,47 @@ int ext4_write_inode(struct inode inode, struct writeback_control wbc)
		return err;
		}

		/*
		* In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
		* buffers that are attached to a page stradding i_size and are undergoing
		* commit. In that case we have to wait for commit to finish and try again.
		*/
		static void ext4_wait_for_tail_page_commit(struct inode *inode)
		{
		struct page *page;
		unsigned offset;
		journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
		tid_t commit_tid = 0;
		int ret;

		offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
		/*
		* All buffers in the last page remain valid? Then there's nothing to
		* do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
		* blocksize case
		*/
		if (offset > PAGE_CACHE_SIZE - (1 << inode->i_blkbits))
		return;
		while (1) {
		page = find_lock_page(inode->i_mapping,
		inode->i_size >> PAGE_CACHE_SHIFT);
		if (!page)
		return;
		ret = __ext4_journalled_invalidatepage(page, offset);
		unlock_page(page);
		page_cache_release(page);
		if (ret != -EBUSY)
		return;
		commit_tid = 0;
		read_lock(&journal->j_state_lock);
		if (journal->j_committing_transaction)
		commit_tid = journal->j_committing_transaction->t_tid;
		read_unlock(&journal->j_state_lock);
		if (commit_tid)
		jbd2_log_wait_commit(journal, commit_tid);
		}
		}

		/*
		* ext4_setattr()
		*
		@@ -4417,16 +4474,28 @@ int ext4_setattr(struct dentry dentry, struct iattr attr)
		}

		if (attr->ia_valid & ATTR_SIZE) {
		if (attr->ia_size != i_size_read(inode)) {
		truncate_setsize(inode, attr->ia_size);
		/* Inode size will be reduced, wait for dio in flight.
		* Temporarily disable dioread_nolock to prevent
		* livelock. */
		if (attr->ia_size != inode->i_size) {
		loff_t oldsize = inode->i_size;

		i_size_write(inode, attr->ia_size);
		/*
		* Blocks are going to be removed from the inode. Wait
		* for dio in flight. Temporarily disable
		* dioread_nolock to prevent livelock.
		*/
		if (orphan) {
		if (!ext4_should_journal_data(inode)) {
		ext4_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);
		ext4_inode_resume_unlocked_dio(inode);
		} else
		ext4_wait_for_tail_page_commit(inode);
		}
		/*
		* Truncate pagecache after we've waited for commit
		* in data=journal mode to make pages freeable.
		*/
		truncate_pagecache(inode, oldsize, inode->i_size);
		}
		ext4_truncate(inode);
		}

fs/ext4/namei.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -2648,7 +2648,8 @@ int ext4_orphan_del(handle_t handle, struct inode inode)
		struct ext4_iloc iloc;
		int err = 0;

		if (!EXT4_SB(inode->i_sb)->s_journal)
		if ((!EXT4_SB(inode->i_sb)->s_journal) &&
		!(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS))
		return 0;

		mutex_lock(&EXT4_SB(inode->i_sb)->s_orphan_lock);

Admin message