Merge tag 'for-4.20-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

Pull btrfs fixes from David Sterba: "Several fixes to recent release (4.19, fixes tagged for stable) and other fixes" * tag 'for-4.20-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: Btrfs: fix missing delayed iputs on unmount Btrfs: fix data corruption due to cloning of eof block Btrfs: fix infinite loop on inode eviction after deduplication of eof block Btrfs: fix deadlock on tree root leaf when finding free extent btrfs: avoid link error with CONFIG_NO_AUTO_INLINE btrfs: tree-checker: Fix misleading group system information Btrfs: fix missing data checksums after a ranged fsync (msync) btrfs: fix pinned underflow after transaction aborted Btrfs: fix cur_offset in the error case for nocow

Linus Torvalds committed 8 years ago

Commit 63a42e12 parents c140f8b d6fd0ae8 files · +107 −57Browse files

Unified · Split

8 files

fs/btrfs/ctree.h +3 −0
fs/btrfs/disk-io.c +26 −37
fs/btrfs/free-space-cache.c +21 −1
fs/btrfs/inode.c +24 −13
fs/btrfs/ioctl.c +12 −2
fs/btrfs/super.c +3 −3
fs/btrfs/tree-checker.c +1 −1
fs/btrfs/tree-log.c +17 −0

fs/btrfs/ctree.h+3−0

 int btrfs_drop_inode(struct inode *inode);
 int __init btrfs_init_cachep(void);
 void __cold btrfs_destroy_cachep(void);
+struct inode *btrfs_iget_path(struct super_block *s, struct btrfs_key *location,
+			      struct btrfs_root *root, int *new,
+			      struct btrfs_path *path);
 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
 			 struct btrfs_root *root, int *was_new);
 struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,

fs/btrfs/disk-io.c+26−37

 	struct btrfs_root *root = arg;
 	struct btrfs_fs_info *fs_info = root->fs_info;
 	int again;
-	struct btrfs_trans_handle *trans;
-	do {
+	while (1) {
 		again = 0;
 		/* Make the cleaner go to sleep early. */
 		 */
 		btrfs_delete_unused_bgs(fs_info);
 sleep:
+		if (kthread_should_park())
+			kthread_parkme();
+		if (kthread_should_stop())
+			return 0;
 		if (!again) {
 			set_current_state(TASK_INTERRUPTIBLE);
-			if (!kthread_should_stop())
+			schedule();
-				schedule();
 			__set_current_state(TASK_RUNNING);
 		}
-	} while (!kthread_should_stop());
-	/*
-	 * Transaction kthread is stopped before us and wakes us up.
-	 * However we might have started a new transaction and COWed some
-	 * tree blocks when deleting unused block groups for example. So
-	 * make sure we commit the transaction we started to have a clean
-	 * shutdown when evicting the btree inode - if it has dirty pages
-	 * when we do the final iput() on it, eviction will trigger a
-	 * writeback for it which will fail with null pointer dereferences
-	 * since work queues and other resources were already released and
-	 * destroyed by the time the iput/eviction/writeback is made.
-	 */
-	trans = btrfs_attach_transaction(root);
-	if (IS_ERR(trans)) {
-		if (PTR_ERR(trans) != -ENOENT)
-			btrfs_err(fs_info,
-				  "cleaner transaction attach returned %ld",
-				  PTR_ERR(trans));
-	} else {
-		int ret;
-		ret = btrfs_commit_transaction(trans);
-		if (ret)
-			btrfs_err(fs_info,
-				  "cleaner open transaction commit returned %d",
-				  ret);
 	}
-	return 0;
 }
 static int transaction_kthread(void *arg)
 	int ret;
 	set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
+	/*
+	 * We don't want the cleaner to start new transactions, add more delayed
+	 * iputs, etc. while we're closing. We can't use kthread_stop() yet
+	 * because that frees the task_struct, and the transaction kthread might
+	 * still try to wake up the cleaner.
+	 */
+	kthread_park(fs_info->cleaner_kthread);
 	/* wait for the qgroup rescan worker to stop */
 	btrfs_qgroup_wait_for_completion(fs_info, false);
 	if (!sb_rdonly(fs_info->sb)) {
 		/*
-		 * If the cleaner thread is stopped and there are
+		 * The cleaner kthread is stopped, so do one final pass over
-		 * block groups queued for removal, the deletion will be
+		 * unused block groups.
-		 * skipped when we quit the cleaner thread.
 		 */
 		btrfs_delete_unused_bgs(fs_info);
 	unpin = pinned_extents;
 again:
 	while (1) {
+		/*
+		 * The btrfs_finish_extent_commit() may get the same range as
+		 * ours between find_first_extent_bit and clear_extent_dirty.
+		 * Hence, hold the unused_bg_unpin_mutex to avoid double unpin
+		 * the same extent range.
+		 */
+		mutex_lock(&fs_info->unused_bg_unpin_mutex);
 		ret = find_first_extent_bit(unpin, 0, &start, &end,
 					    EXTENT_DIRTY, NULL);
-		if (ret)
+		if (ret) {
+			mutex_unlock(&fs_info->unused_bg_unpin_mutex);
 			break;
+		}
 		clear_extent_dirty(unpin, start, end);
 		btrfs_error_unpin_extent_range(fs_info, start, end);
+		mutex_unlock(&fs_info->unused_bg_unpin_mutex);
 		cond_resched();
 	}

fs/btrfs/free-space-cache.c+21−1

@@ -75,7 +75,8 @@ static struct inode __lookup_free_space_inode(struct btrfs_root root, · 74 unmodified lines
75	* sure NOFS is set to keep us from deadlocking.	75	* sure NOFS is set to keep us from deadlocking.
76	*/	76	*/
77	nofs_flag = memalloc_nofs_save();	77	nofs_flag = memalloc_nofs_save();
78	inode = btrfs_iget(fs_info->sb, &location, root, NULL);	78	inode = btrfs_iget_path(fs_info->sb, &location, root, NULL, path);
		79	btrfs_release_path(path);
79	memalloc_nofs_restore(nofs_flag);	80	memalloc_nofs_restore(nofs_flag);
80	if (IS_ERR(inode))	81	if (IS_ERR(inode))
81	return inode;	82	return inode;
@@ -838,6 +839,25 @@ int load_free_space_cache(struct btrfs_fs_info *fs_info, · 756 unmodified lines
838	path->search_commit_root = 1;	839	path->search_commit_root = 1;
839	path->skip_locking = 1;	840	path->skip_locking = 1;
840		841
		842	/*
		843	* We must pass a path with search_commit_root set to btrfs_iget in
		844	* order to avoid a deadlock when allocating extents for the tree root.
		845	*
		846	* When we are COWing an extent buffer from the tree root, when looking
		847	* for a free extent, at extent-tree.c:find_free_extent(), we can find
		848	* block group without its free space cache loaded. When we find one
		849	* we must load its space cache which requires reading its free space
		850	* cache's inode item from the root tree. If this inode item is located
		851	* in the same leaf that we started COWing before, then we end up in
		852	* deadlock on the extent buffer (trying to read lock it when we
		853	* previously write locked it).
		854	*
		855	* It's safe to read the inode item using the commit root because
		856	* block groups, once loaded, stay in memory forever (until they are
		857	* removed) as well as their space caches once loaded. New block groups
		858	* once created get their ->cached field set to BTRFS_CACHE_FINISHED so
		859	* we will never try to read their inode item while the fs is mounted.
		860	*/
841	inode = lookup_free_space_inode(fs_info, block_group, path);	861	inode = lookup_free_space_inode(fs_info, block_group, path);
842	if (IS_ERR(inode)) {	862	if (IS_ERR(inode)) {
843	btrfs_free_path(path);	863	btrfs_free_path(path);

fs/btrfs/inode.c+24−13

 	}
 	btrfs_release_path(path);
-	if (cur_offset <= end && cow_start == (u64)-1) {
+	if (cur_offset <= end && cow_start == (u64)-1)
 		cow_start = cur_offset;
-		cur_offset = end;
-	}
 	if (cow_start != (u64)-1) {
+		cur_offset = end;
 		ret = cow_file_range(inode, locked_page, cow_start, end, end,
 				     page_started, nr_written, 1, NULL);
 		if (ret)
 /*
  * read an inode from the btree into the in-memory inode
  */
-static int btrfs_read_locked_inode(struct inode *inode)
+static int btrfs_read_locked_inode(struct inode *inode,
+				   struct btrfs_path *in_path)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-	struct btrfs_path *path;
+	struct btrfs_path *path = in_path;
 	struct extent_buffer *leaf;
 	struct btrfs_inode_item *inode_item;
 	struct btrfs_root *root = BTRFS_I(inode)->root;
 	if (!ret)
 		filled = true;
-	path = btrfs_alloc_path();
+	if (!path) {
-	if (!path)
+		path = btrfs_alloc_path();
-		return -ENOMEM;
+		if (!path)
+			return -ENOMEM;
+	}
 	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
 	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
 	if (ret) {
-		btrfs_free_path(path);
+		if (path != in_path)
+			btrfs_free_path(path);
 		return ret;
 	}
 				  btrfs_ino(BTRFS_I(inode)),
 				  root->root_key.objectid, ret);
 	}
-	btrfs_free_path(path);
+	if (path != in_path)
+		btrfs_free_path(path);
 	if (!maybe_acls)
 		cache_no_acl(inode);
 /* Get an inode object given its location and corresponding root.
  * Returns in *is_new if the inode was read from disk
  */
-struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
+struct inode *btrfs_iget_path(struct super_block *s, struct btrfs_key *location,
-			 struct btrfs_root *root, int *new)
+			      struct btrfs_root *root, int *new,
+			      struct btrfs_path *path)
 {
 	struct inode *inode;
 	if (inode->i_state & I_NEW) {
 		int ret;
-		ret = btrfs_read_locked_inode(inode);
+		ret = btrfs_read_locked_inode(inode, path);
 		if (!ret) {
 			inode_tree_add(inode);
 			unlock_new_inode(inode);
 	return inode;
 }
+struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
+			 struct btrfs_root *root, int *new)
+{
+	return btrfs_iget_path(s, location, root, new, NULL);
+}
 static struct inode *new_simple_dir(struct super_block *s,
 				    struct btrfs_key *key,
 				    struct btrfs_root *root)

fs/btrfs/ioctl.c+12−2

 			const u64 sz = BTRFS_I(src)->root->fs_info->sectorsize;
 			len = round_down(i_size_read(src), sz) - loff;
+			if (len == 0)
+				return 0;
 			olen = len;
 		}
 	}
 		goto out_unlock;
 	if (len == 0)
 		olen = len = src->i_size - off;
-	/* if we extend to eof, continue to block boundary */
+	/*
-	if (off + len == src->i_size)
+	 * If we extend to eof, continue to block boundary if and only if the
+	 * destination end offset matches the destination file's size, otherwise
+	 * we would be corrupting data by placing the eof block into the middle
+	 * of a file.
+	 */
+	if (off + len == src->i_size) {
+		if (!IS_ALIGNED(len, bs) && destoff + len < inode->i_size)
+			goto out_unlock;
 		len = ALIGN(src->i_size, bs) - off;
+	}
 	if (len == 0) {
 		ret = 0;

fs/btrfs/super.c+3−3

@@ -1916,7 +1916,7 @@ restore: · 1915 unmodified lines
1916	}	1916	}
1917		1917
1918	/* Used to sort the devices by max_avail(descending sort) */	1918	/* Used to sort the devices by max_avail(descending sort) */
1919	static int btrfs_cmp_device_free_bytes(const void *dev_info1,	1919	static inline int btrfs_cmp_device_free_bytes(const void *dev_info1,
1920	const void *dev_info2)	1920	const void *dev_info2)
1921	{	1921	{
1922	if (((struct btrfs_device_info *)dev_info1)->max_avail >	1922	if (((struct btrfs_device_info *)dev_info1)->max_avail >
@@ -1945,8 +1945,8 @@ static inline void btrfs_descending_sort_devices( · 22 unmodified lines
1945	* The helper to calc the free space on the devices that can be used to store	1945	* The helper to calc the free space on the devices that can be used to store
1946	* file data.	1946	* file data.
1947	*/	1947	*/
1948	static int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,	1948	static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,
1949	u64 *free_bytes)	1949	u64 *free_bytes)
1950	{	1950	{
1951	struct btrfs_device_info *devices_info;	1951	struct btrfs_device_info *devices_info;
1952	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;	1952	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

fs/btrfs/tree-checker.c+1−1

@@ -440,7 +440,7 @@ static int check_block_group_item(struct btrfs_fs_info *fs_info, · 439 unmodified lines
440	type != (BTRFS_BLOCK_GROUP_METADATA \|	440	type != (BTRFS_BLOCK_GROUP_METADATA \|
441	BTRFS_BLOCK_GROUP_DATA)) {	441	BTRFS_BLOCK_GROUP_DATA)) {
442	block_group_err(fs_info, leaf, slot,	442	block_group_err(fs_info, leaf, slot,
443	"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llu or 0x%llx",	443	"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx",
444	type, hweight64(type),	444	type, hweight64(type),
445	BTRFS_BLOCK_GROUP_DATA, BTRFS_BLOCK_GROUP_METADATA,	445	BTRFS_BLOCK_GROUP_DATA, BTRFS_BLOCK_GROUP_METADATA,
446	BTRFS_BLOCK_GROUP_SYSTEM,	446	BTRFS_BLOCK_GROUP_SYSTEM,

fs/btrfs/tree-log.c+17−0

@@ -4396,6 +4396,23 @@ static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans, · 4395 unmodified lines
4396	logged_end = end;	4396	logged_end = end;
4397		4397
4398	list_for_each_entry_safe(em, n, &tree->modified_extents, list) {	4398	list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
		4399	/*
		4400	* Skip extents outside our logging range. It's important to do
		4401	* it for correctness because if we don't ignore them, we may
		4402	* log them before their ordered extent completes, and therefore
		4403	* we could log them without logging their respective checksums
		4404	* (the checksum items are added to the csum tree at the very
		4405	* end of btrfs_finish_ordered_io()). Also leave such extents
		4406	* outside of our range in the list, since we may have another
		4407	* ranged fsync in the near future that needs them. If an extent
		4408	* outside our range corresponds to a hole, log it to avoid
		4409	* leaving gaps between extents (fsck will complain when we are
		4410	* not using the NO_HOLES feature).
		4411	*/
		4412	if ((em->start > end \|\| em->start + em->len <= start) &&
		4413	em->block_start != EXTENT_MAP_HOLE)
		4414	continue;
		4415
4399	list_del_init(&em->list);	4416	list_del_init(&em->list);
4400	/*	4417	/*
4401	* Just an arbitrary number, this can be really CPU intensive	4418	* Just an arbitrary number, this can be really CPU intensive