Commit a18f8775 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull btrfs updates from David Sterba:
 "Highlights:

   - chunks that have been trimmed and unchanged since last mount are
     tracked and skipped on repeated trims

   - use hw assissed crc32c on more arches, speedups if native
     instructions or optimized implementation is available

   - the RAID56 incompat bit is automatically removed when the last
     block group of that type is removed

  Fixes:

   - fsync fix for reflink on NODATACOW files that could lead to ENOSPC

   - fix data loss after inode eviction, renaming it, and fsync it

   - fix fsync not persisting dentry deletions due to inode evictions

   - update ctime/mtime/iversion after hole punching

   - fix compression type validation (reported by KASAN)

   - send won't be allowed to start when relocation is in progress, this
     can cause spurious errors or produce incorrect send stream

  Core:

   - new tracepoints for space update

   - tree-checker: better check for end of extents for some tree items

   - preparatory work for more checksum algorithms

   - run delayed iput at unlink time and don't push the work to cleaner
     thread where it's not properly throttled

   - wrap block mapping to structures and helpers, base for further
     refactoring

   - split large files, part 1:
       - space info handling
       - block group reservations
       - delayed refs
       - delayed allocation

   - other cleanups and refactoring"

* tag 'for-5.3-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (103 commits)
  btrfs: fix memory leak of path on error return path
  btrfs: move the subvolume reservation stuff out of extent-tree.c
  btrfs: migrate the delalloc space stuff to it's own home
  btrfs: migrate btrfs_trans_release_chunk_metadata
  btrfs: migrate the delayed refs rsv code
  btrfs: Evaluate io_tree in find_lock_delalloc_range()
  btrfs: migrate the global_block_rsv helpers to block-rsv.c
  btrfs: migrate the block-rsv code to block-rsv.c
  btrfs: stop using block_rsv_release_bytes everywhere
  btrfs: cleanup the target logic in __btrfs_block_rsv_release
  btrfs: export __btrfs_block_rsv_release
  btrfs: export btrfs_block_rsv_add_bytes
  btrfs: move btrfs_block_rsv definitions into it's own header
  btrfs: Simplify update of space_info in __reserve_metadata_bytes()
  btrfs: unexport can_overcommit
  btrfs: move reserve_metadata_bytes and supporting code to space-info.c
  btrfs: move dump_space_info to space-info.c
  btrfs: export block_rsv_use_bytes
  btrfs: move btrfs_space_info_add_*_bytes to space-info.c
  btrfs: move the space info update macro to space-info.h
  ...
parents 3eb51486 e02d48ea

fs/btrfs/Kconfig

+2 −1
Original line number Diff line number Diff line
@@ -2,7 +2,8 @@ 


config BTRFS_FS

	tristate "Btrfs filesystem support"

	select LIBCRC32C

	select CRYPTO

	select CRYPTO_CRC32C

	select ZLIB_INFLATE

	select ZLIB_DEFLATE

	select LZO_COMPRESS

fs/btrfs/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -10,7 +10,8 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ 
	   export.o tree-log.o free-space-cache.o zlib.o lzo.o zstd.o \

	   compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \

	   reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \

	   uuid-tree.o props.o free-space-tree.o tree-checker.o

	   uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \

	   block-rsv.o delalloc-space.o



btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o

btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o

fs/btrfs/backref.c

+6 −11
Original line number Diff line number Diff line
@@ -1465,12 +1465,11 @@ int btrfs_find_all_roots(struct btrfs_trans_handle *trans, 
 *

 * Return: 0 if extent is not shared, 1 if it is shared, < 0 on error.

 */

int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr)

int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr,

		struct ulist *roots, struct ulist *tmp)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_trans_handle *trans;

	struct ulist *tmp = NULL;

	struct ulist *roots = NULL;

	struct ulist_iterator uiter;

	struct ulist_node *node;

	struct seq_list elem = SEQ_LIST_INIT(elem);
@@ -1481,12 +1480,8 @@ int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr) 
		.share_count = 0,

	};



	tmp = ulist_alloc(GFP_NOFS);

	roots = ulist_alloc(GFP_NOFS);

	if (!tmp || !roots) {

		ret = -ENOMEM;

		goto out;

	}

	ulist_init(roots);

	ulist_init(tmp);



	trans = btrfs_attach_transaction(root);

	if (IS_ERR(trans)) {
@@ -1527,8 +1522,8 @@ int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr) 
		up_read(&fs_info->commit_root_sem);

	}

out:

	ulist_free(tmp);

	ulist_free(roots);

	ulist_release(roots);

	ulist_release(tmp);

	return ret;

}

fs/btrfs/backref.h

+2 −1
Original line number Diff line number Diff line
@@ -57,7 +57,8 @@ int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid, 
			  u64 start_off, struct btrfs_path *path,

			  struct btrfs_inode_extref **ret_extref,

			  u64 *found_off);

int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr);

int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr,

		struct ulist *roots, struct ulist *tmp_ulist);



int __init btrfs_prelim_ref_init(void);

void __cold btrfs_prelim_ref_exit(void);

fs/btrfs/block-rsv.c

0 → 100644
+425 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include "ctree.h"

#include "block-rsv.h"

#include "space-info.h"

#include "math.h"

#include "transaction.h"



static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,

				    struct btrfs_block_rsv *block_rsv,

				    struct btrfs_block_rsv *dest, u64 num_bytes,

				    u64 *qgroup_to_release_ret)

{

	struct btrfs_space_info *space_info = block_rsv->space_info;

	u64 qgroup_to_release = 0;

	u64 ret;



	spin_lock(&block_rsv->lock);

	if (num_bytes == (u64)-1) {

		num_bytes = block_rsv->size;

		qgroup_to_release = block_rsv->qgroup_rsv_size;

	}

	block_rsv->size -= num_bytes;

	if (block_rsv->reserved >= block_rsv->size) {

		num_bytes = block_rsv->reserved - block_rsv->size;

		block_rsv->reserved = block_rsv->size;

		block_rsv->full = 1;

	} else {

		num_bytes = 0;

	}

	if (block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {

		qgroup_to_release = block_rsv->qgroup_rsv_reserved -

				    block_rsv->qgroup_rsv_size;

		block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;

	} else {

		qgroup_to_release = 0;

	}

	spin_unlock(&block_rsv->lock);



	ret = num_bytes;

	if (num_bytes > 0) {

		if (dest) {

			spin_lock(&dest->lock);

			if (!dest->full) {

				u64 bytes_to_add;



				bytes_to_add = dest->size - dest->reserved;

				bytes_to_add = min(num_bytes, bytes_to_add);

				dest->reserved += bytes_to_add;

				if (dest->reserved >= dest->size)

					dest->full = 1;

				num_bytes -= bytes_to_add;

			}

			spin_unlock(&dest->lock);

		}

		if (num_bytes)

			btrfs_space_info_add_old_bytes(fs_info, space_info,

						       num_bytes);

	}

	if (qgroup_to_release_ret)

		*qgroup_to_release_ret = qgroup_to_release;

	return ret;

}



int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,

			    struct btrfs_block_rsv *dst, u64 num_bytes,

			    bool update_size)

{

	int ret;



	ret = btrfs_block_rsv_use_bytes(src, num_bytes);

	if (ret)

		return ret;



	btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);

	return 0;

}



void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)

{

	memset(rsv, 0, sizeof(*rsv));

	spin_lock_init(&rsv->lock);

	rsv->type = type;

}



void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,

				   struct btrfs_block_rsv *rsv,

				   unsigned short type)

{

	btrfs_init_block_rsv(rsv, type);

	rsv->space_info = btrfs_find_space_info(fs_info,

					    BTRFS_BLOCK_GROUP_METADATA);

}



struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,

					      unsigned short type)

{

	struct btrfs_block_rsv *block_rsv;



	block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);

	if (!block_rsv)

		return NULL;



	btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);

	return block_rsv;

}



void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,

			  struct btrfs_block_rsv *rsv)

{

	if (!rsv)

		return;

	btrfs_block_rsv_release(fs_info, rsv, (u64)-1);

	kfree(rsv);

}



int btrfs_block_rsv_add(struct btrfs_root *root,

			struct btrfs_block_rsv *block_rsv, u64 num_bytes,

			enum btrfs_reserve_flush_enum flush)

{

	int ret;



	if (num_bytes == 0)

		return 0;



	ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);

	if (!ret)

		btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);



	return ret;

}



int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor)

{

	u64 num_bytes = 0;

	int ret = -ENOSPC;



	if (!block_rsv)

		return 0;



	spin_lock(&block_rsv->lock);

	num_bytes = div_factor(block_rsv->size, min_factor);

	if (block_rsv->reserved >= num_bytes)

		ret = 0;

	spin_unlock(&block_rsv->lock);



	return ret;

}



int btrfs_block_rsv_refill(struct btrfs_root *root,

			   struct btrfs_block_rsv *block_rsv, u64 min_reserved,

			   enum btrfs_reserve_flush_enum flush)

{

	u64 num_bytes = 0;

	int ret = -ENOSPC;



	if (!block_rsv)

		return 0;



	spin_lock(&block_rsv->lock);

	num_bytes = min_reserved;

	if (block_rsv->reserved >= num_bytes)

		ret = 0;

	else

		num_bytes -= block_rsv->reserved;

	spin_unlock(&block_rsv->lock);



	if (!ret)

		return 0;



	ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);

	if (!ret) {

		btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);

		return 0;

	}



	return ret;

}



u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,

			      struct btrfs_block_rsv *block_rsv,

			      u64 num_bytes, u64 *qgroup_to_release)

{

	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

	struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;

	struct btrfs_block_rsv *target = NULL;



	/*

	 * If we are the delayed_rsv then push to the global rsv, otherwise dump

	 * into the delayed rsv if it is not full.

	 */

	if (block_rsv == delayed_rsv)

		target = global_rsv;

	else if (block_rsv != global_rsv && !delayed_rsv->full)

		target = delayed_rsv;



	if (target && block_rsv->space_info != target->space_info)

		target = NULL;



	return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,

				       qgroup_to_release);

}



int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes)

{

	int ret = -ENOSPC;



	spin_lock(&block_rsv->lock);

	if (block_rsv->reserved >= num_bytes) {

		block_rsv->reserved -= num_bytes;

		if (block_rsv->reserved < block_rsv->size)

			block_rsv->full = 0;

		ret = 0;

	}

	spin_unlock(&block_rsv->lock);

	return ret;

}



void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,

			       u64 num_bytes, bool update_size)

{

	spin_lock(&block_rsv->lock);

	block_rsv->reserved += num_bytes;

	if (update_size)

		block_rsv->size += num_bytes;

	else if (block_rsv->reserved >= block_rsv->size)

		block_rsv->full = 1;

	spin_unlock(&block_rsv->lock);

}



int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,

			     struct btrfs_block_rsv *dest, u64 num_bytes,

			     int min_factor)

{

	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

	u64 min_bytes;



	if (global_rsv->space_info != dest->space_info)

		return -ENOSPC;



	spin_lock(&global_rsv->lock);

	min_bytes = div_factor(global_rsv->size, min_factor);

	if (global_rsv->reserved < min_bytes + num_bytes) {

		spin_unlock(&global_rsv->lock);

		return -ENOSPC;

	}

	global_rsv->reserved -= num_bytes;

	if (global_rsv->reserved < global_rsv->size)

		global_rsv->full = 0;

	spin_unlock(&global_rsv->lock);



	btrfs_block_rsv_add_bytes(dest, num_bytes, true);

	return 0;

}



void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)

{

	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;

	struct btrfs_space_info *sinfo = block_rsv->space_info;

	u64 num_bytes;



	/*

	 * The global block rsv is based on the size of the extent tree, the

	 * checksum tree and the root tree.  If the fs is empty we want to set

	 * it to a minimal amount for safety.

	 */

	num_bytes = btrfs_root_used(&fs_info->extent_root->root_item) +

		btrfs_root_used(&fs_info->csum_root->root_item) +

		btrfs_root_used(&fs_info->tree_root->root_item);

	num_bytes = max_t(u64, num_bytes, SZ_16M);



	spin_lock(&sinfo->lock);

	spin_lock(&block_rsv->lock);



	block_rsv->size = min_t(u64, num_bytes, SZ_512M);



	if (block_rsv->reserved < block_rsv->size) {

		num_bytes = btrfs_space_info_used(sinfo, true);

		if (sinfo->total_bytes > num_bytes) {

			num_bytes = sinfo->total_bytes - num_bytes;

			num_bytes = min(num_bytes,

					block_rsv->size - block_rsv->reserved);

			block_rsv->reserved += num_bytes;

			btrfs_space_info_update_bytes_may_use(fs_info, sinfo,

							      num_bytes);

			trace_btrfs_space_reservation(fs_info, "space_info",

						      sinfo->flags, num_bytes,

						      1);

		}

	} else if (block_rsv->reserved > block_rsv->size) {

		num_bytes = block_rsv->reserved - block_rsv->size;

		btrfs_space_info_update_bytes_may_use(fs_info, sinfo,

						      -num_bytes);

		trace_btrfs_space_reservation(fs_info, "space_info",

				      sinfo->flags, num_bytes, 0);

		block_rsv->reserved = block_rsv->size;

	}



	if (block_rsv->reserved == block_rsv->size)

		block_rsv->full = 1;

	else

		block_rsv->full = 0;



	spin_unlock(&block_rsv->lock);

	spin_unlock(&sinfo->lock);

}



void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)

{

	struct btrfs_space_info *space_info;



	space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);

	fs_info->chunk_block_rsv.space_info = space_info;



	space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);

	fs_info->global_block_rsv.space_info = space_info;

	fs_info->trans_block_rsv.space_info = space_info;

	fs_info->empty_block_rsv.space_info = space_info;

	fs_info->delayed_block_rsv.space_info = space_info;

	fs_info->delayed_refs_rsv.space_info = space_info;



	fs_info->extent_root->block_rsv = &fs_info->delayed_refs_rsv;

	fs_info->csum_root->block_rsv = &fs_info->delayed_refs_rsv;

	fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;

	fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;

	if (fs_info->quota_root)

		fs_info->quota_root->block_rsv = &fs_info->global_block_rsv;

	fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;



	btrfs_update_global_block_rsv(fs_info);

}



void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)

{

	btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1);

	WARN_ON(fs_info->trans_block_rsv.size > 0);

	WARN_ON(fs_info->trans_block_rsv.reserved > 0);

	WARN_ON(fs_info->chunk_block_rsv.size > 0);

	WARN_ON(fs_info->chunk_block_rsv.reserved > 0);

	WARN_ON(fs_info->delayed_block_rsv.size > 0);

	WARN_ON(fs_info->delayed_block_rsv.reserved > 0);

	WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);

	WARN_ON(fs_info->delayed_refs_rsv.size > 0);

}



static struct btrfs_block_rsv *get_block_rsv(

					const struct btrfs_trans_handle *trans,

					const struct btrfs_root *root)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_block_rsv *block_rsv = NULL;



	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||

	    (root == fs_info->csum_root && trans->adding_csums) ||

	    (root == fs_info->uuid_root))

		block_rsv = trans->block_rsv;



	if (!block_rsv)

		block_rsv = root->block_rsv;



	if (!block_rsv)

		block_rsv = &fs_info->empty_block_rsv;



	return block_rsv;

}



struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans,

					    struct btrfs_root *root,

					    u32 blocksize)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_block_rsv *block_rsv;

	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;

	int ret;

	bool global_updated = false;



	block_rsv = get_block_rsv(trans, root);



	if (unlikely(block_rsv->size == 0))

		goto try_reserve;

again:

	ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize);

	if (!ret)

		return block_rsv;



	if (block_rsv->failfast)

		return ERR_PTR(ret);



	if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {

		global_updated = true;

		btrfs_update_global_block_rsv(fs_info);

		goto again;

	}



	/*

	 * The global reserve still exists to save us from ourselves, so don't

	 * warn_on if we are short on our delayed refs reserve.

	 */

	if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&

	    btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {

		static DEFINE_RATELIMIT_STATE(_rs,

				DEFAULT_RATELIMIT_INTERVAL * 10,

				/*DEFAULT_RATELIMIT_BURST*/ 1);

		if (__ratelimit(&_rs))

			WARN(1, KERN_DEBUG

				"BTRFS: block rsv returned %d\n", ret);

	}

try_reserve:

	ret = btrfs_reserve_metadata_bytes(root, block_rsv, blocksize,

					   BTRFS_RESERVE_NO_FLUSH);

	if (!ret)

		return block_rsv;

	/*

	 * If we couldn't reserve metadata bytes try and use some from

	 * the global reserve if its space type is the same as the global

	 * reservation.

	 */

	if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&

	    block_rsv->space_info == global_rsv->space_info) {

		ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize);

		if (!ret)

			return global_rsv;

	}

	return ERR_PTR(ret);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE