btrfs: remove old unused commented out code (182608c8) · Commits · 戴 / test

fs/btrfs/delayed-ref.c

+0 −76

Original line number	Original line	Diff line number	Diff line
	@@ -709,79 +709,3 @@ btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr)
	return btrfs_delayed_node_to_head(ref);		return btrfs_delayed_node_to_head(ref);
	return NULL;		return NULL;
	}		}

	/*
	* add a delayed ref to the tree. This does all of the accounting required
	* to make sure the delayed ref is eventually processed before this
	* transaction commits.
	*
	* The main point of this call is to add and remove a backreference in a single
	* shot, taking the lock only once, and only searching for the head node once.
	*
	* It is the same as doing a ref add and delete in two separate calls.
	*/
	#if 0
	int btrfs_update_delayed_ref(struct btrfs_trans_handle *trans,
	u64 bytenr, u64 num_bytes, u64 orig_parent,
	u64 parent, u64 orig_ref_root, u64 ref_root,
	u64 orig_ref_generation, u64 ref_generation,
	u64 owner_objectid, int pin)
	{
	struct btrfs_delayed_ref *ref;
	struct btrfs_delayed_ref *old_ref;
	struct btrfs_delayed_ref_head *head_ref;
	struct btrfs_delayed_ref_root *delayed_refs;
	int ret;

	ref = kmalloc(sizeof(*ref), GFP_NOFS);
	if (!ref)
	return -ENOMEM;

	old_ref = kmalloc(sizeof(*old_ref), GFP_NOFS);
	if (!old_ref) {
	kfree(ref);
	return -ENOMEM;
	}

	/*
	* the parent = 0 case comes from cases where we don't actually
	* know the parent yet. It will get updated later via a add/drop
	* pair.
	*/
	if (parent == 0)
	parent = bytenr;
	if (orig_parent == 0)
	orig_parent = bytenr;

	head_ref = kmalloc(sizeof(*head_ref), GFP_NOFS);
	if (!head_ref) {
	kfree(ref);
	kfree(old_ref);
	return -ENOMEM;
	}
	delayed_refs = &trans->transaction->delayed_refs;
	spin_lock(&delayed_refs->lock);

	/*
	* insert both the head node and the new ref without dropping
	* the spin lock
	*/
	ret = __btrfs_add_delayed_ref(trans, &head_ref->node, bytenr, num_bytes,
	(u64)-1, 0, 0, 0,
	BTRFS_UPDATE_DELAYED_HEAD, 0);
	BUG_ON(ret);

	ret = __btrfs_add_delayed_ref(trans, &ref->node, bytenr, num_bytes,
	parent, ref_root, ref_generation,
	owner_objectid, BTRFS_ADD_DELAYED_REF, 0);
	BUG_ON(ret);

	ret = __btrfs_add_delayed_ref(trans, &old_ref->node, bytenr, num_bytes,
	orig_parent, orig_ref_root,
	orig_ref_generation, owner_objectid,
	BTRFS_DROP_DELAYED_REF, pin);
	BUG_ON(ret);
	spin_unlock(&delayed_refs->lock);
	return 0;
	}
	#endif

fs/btrfs/disk-io.c

+0 −29

Original line number	Original line	Diff line number	Diff line
	@@ -1348,35 +1348,6 @@ fail:
	return ERR_PTR(ret);		return ERR_PTR(ret);
	}		}

	#if 0
	struct btrfs_root *root;
	int ret;

	root = btrfs_read_fs_root_no_name(fs_info, location);
	if (!root)
	return NULL;

	if (root->in_sysfs)
	return root;

	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
	free_extent_buffer(root->node);
	kfree(root);
	return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
	free_extent_buffer(root->node);
	kfree(root->name);
	kfree(root);
	return ERR_PTR(ret);
	}
	root->in_sysfs = 1;
	return root;
	#endif

	static int btrfs_congested_fn(void *congested_data, int bdi_bits)		static int btrfs_congested_fn(void *congested_data, int bdi_bits)
	{		{
	struct btrfs_fs_info info = (struct btrfs_fs_info )congested_data;		struct btrfs_fs_info info = (struct btrfs_fs_info )congested_data;

Admin message