Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 182608c8 authored by David Sterba's avatar David Sterba
Browse files

btrfs: remove old unused commented out code 



Remove code which has been #if0-ed out for a very long time and does not
seem to be related to current codebase anymore.

Signed-off-by: default avatarDavid Sterba <dsterba@suse.cz>
parent f2a97a9d

fs/btrfs/delayed-ref.c

+0 −76
Original line number 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 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 Diff line number Diff line
@@ -1348,35 +1348,6 @@ fail: 
	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)

{

	struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;

fs/btrfs/extent-tree.c

+1 −1660

File changed.

Preview size limit exceeded, changes collapsed.

fs/btrfs/inode.c

+0 −172
Original line number Diff line number Diff line
@@ -3093,178 +3093,6 @@ out: 
	return err;

}



#if 0

/*

 * when truncating bytes in a file, it is possible to avoid reading

 * the leaves that contain only checksum items.  This can be the

 * majority of the IO required to delete a large file, but it must

 * be done carefully.

 *

 * The keys in the level just above the leaves are checked to make sure

 * the lowest key in a given leaf is a csum key, and starts at an offset

 * after the new  size.

 *

 * Then the key for the next leaf is checked to make sure it also has

 * a checksum item for the same file.  If it does, we know our target leaf

 * contains only checksum items, and it can be safely freed without reading

 * it.

 *

 * This is just an optimization targeted at large files.  It may do

 * nothing.  It will return 0 unless things went badly.

 */

static noinline int drop_csum_leaves(struct btrfs_trans_handle *trans,

				     struct btrfs_root *root,

				     struct btrfs_path *path,

				     struct inode *inode, u64 new_size)

{

	struct btrfs_key key;

	int ret;

	int nritems;

	struct btrfs_key found_key;

	struct btrfs_key other_key;

	struct btrfs_leaf_ref *ref;

	u64 leaf_gen;

	u64 leaf_start;



	path->lowest_level = 1;

	key.objectid = inode->i_ino;

	key.type = BTRFS_CSUM_ITEM_KEY;

	key.offset = new_size;

again:

	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);

	if (ret < 0)

		goto out;



	if (path->nodes[1] == NULL) {

		ret = 0;

		goto out;

	}

	ret = 0;

	btrfs_node_key_to_cpu(path->nodes[1], &found_key, path->slots[1]);

	nritems = btrfs_header_nritems(path->nodes[1]);



	if (!nritems)

		goto out;



	if (path->slots[1] >= nritems)

		goto next_node;



	/* did we find a key greater than anything we want to delete? */

	if (found_key.objectid > inode->i_ino ||

	   (found_key.objectid == inode->i_ino && found_key.type > key.type))

		goto out;



	/* we check the next key in the node to make sure the leave contains

	 * only checksum items.  This comparison doesn't work if our

	 * leaf is the last one in the node

	 */

	if (path->slots[1] + 1 >= nritems) {

next_node:

		/* search forward from the last key in the node, this

		 * will bring us into the next node in the tree

		 */

		btrfs_node_key_to_cpu(path->nodes[1], &found_key, nritems - 1);



		/* unlikely, but we inc below, so check to be safe */

		if (found_key.offset == (u64)-1)

			goto out;



		/* search_forward needs a path with locks held, do the

		 * search again for the original key.  It is possible

		 * this will race with a balance and return a path that

		 * we could modify, but this drop is just an optimization

		 * and is allowed to miss some leaves.

		 */

		btrfs_release_path(root, path);

		found_key.offset++;



		/* setup a max key for search_forward */

		other_key.offset = (u64)-1;

		other_key.type = key.type;

		other_key.objectid = key.objectid;



		path->keep_locks = 1;

		ret = btrfs_search_forward(root, &found_key, &other_key,

					   path, 0, 0);

		path->keep_locks = 0;

		if (ret || found_key.objectid != key.objectid ||

		    found_key.type != key.type) {

			ret = 0;

			goto out;

		}



		key.offset = found_key.offset;

		btrfs_release_path(root, path);

		cond_resched();

		goto again;

	}



	/* we know there's one more slot after us in the tree,

	 * read that key so we can verify it is also a checksum item

	 */

	btrfs_node_key_to_cpu(path->nodes[1], &other_key, path->slots[1] + 1);



	if (found_key.objectid < inode->i_ino)

		goto next_key;



	if (found_key.type != key.type || found_key.offset < new_size)

		goto next_key;



	/*

	 * if the key for the next leaf isn't a csum key from this objectid,

	 * we can't be sure there aren't good items inside this leaf.

	 * Bail out

	 */

	if (other_key.objectid != inode->i_ino || other_key.type != key.type)

		goto out;



	leaf_start = btrfs_node_blockptr(path->nodes[1], path->slots[1]);

	leaf_gen = btrfs_node_ptr_generation(path->nodes[1], path->slots[1]);

	/*

	 * it is safe to delete this leaf, it contains only

	 * csum items from this inode at an offset >= new_size

	 */

	ret = btrfs_del_leaf(trans, root, path, leaf_start);

	BUG_ON(ret);



	if (root->ref_cows && leaf_gen < trans->transid) {

		ref = btrfs_alloc_leaf_ref(root, 0);

		if (ref) {

			ref->root_gen = root->root_key.offset;

			ref->bytenr = leaf_start;

			ref->owner = 0;

			ref->generation = leaf_gen;

			ref->nritems = 0;



			btrfs_sort_leaf_ref(ref);



			ret = btrfs_add_leaf_ref(root, ref, 0);

			WARN_ON(ret);

			btrfs_free_leaf_ref(root, ref);

		} else {

			WARN_ON(1);

		}

	}

next_key:

	btrfs_release_path(root, path);



	if (other_key.objectid == inode->i_ino &&

	    other_key.type == key.type && other_key.offset > key.offset) {

		key.offset = other_key.offset;

		cond_resched();

		goto again;

	}

	ret = 0;

out:

	/* fixup any changes we've made to the path */

	path->lowest_level = 0;

	path->keep_locks = 0;

	btrfs_release_path(root, path);

	return ret;

}



#endif



/*

 * this can truncate away extent items, csum items and directory items.

 * It starts at a high offset and removes keys until it can't find

fs/btrfs/transaction.c

+0 −134
Original line number Diff line number Diff line
@@ -346,49 +346,6 @@ out_unlock: 
	return ret;

}



#if 0

/*

 * rate limit against the drop_snapshot code.  This helps to slow down new

 * operations if the drop_snapshot code isn't able to keep up.

 */

static void throttle_on_drops(struct btrfs_root *root)

{

	struct btrfs_fs_info *info = root->fs_info;

	int harder_count = 0;



harder:

	if (atomic_read(&info->throttles)) {

		DEFINE_WAIT(wait);

		int thr;

		thr = atomic_read(&info->throttle_gen);



		do {

			prepare_to_wait(&info->transaction_throttle,

					&wait, TASK_UNINTERRUPTIBLE);

			if (!atomic_read(&info->throttles)) {

				finish_wait(&info->transaction_throttle, &wait);

				break;

			}

			schedule();

			finish_wait(&info->transaction_throttle, &wait);

		} while (thr == atomic_read(&info->throttle_gen));

		harder_count++;



		if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&

		    harder_count < 2)

			goto harder;



		if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&

		    harder_count < 10)

			goto harder;



		if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&

		    harder_count < 20)

			goto harder;

	}

}

#endif



void btrfs_throttle(struct btrfs_root *root)

{

	mutex_lock(&root->fs_info->trans_mutex);
@@ -808,97 +765,6 @@ int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 
	return ret;

}



#if 0

/*

 * when dropping snapshots, we generate a ton of delayed refs, and it makes

 * sense not to join the transaction while it is trying to flush the current

 * queue of delayed refs out.

 *

 * This is used by the drop snapshot code only

 */

static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)

{

	DEFINE_WAIT(wait);



	mutex_lock(&info->trans_mutex);

	while (info->running_transaction &&

	       info->running_transaction->delayed_refs.flushing) {

		prepare_to_wait(&info->transaction_wait, &wait,

				TASK_UNINTERRUPTIBLE);

		mutex_unlock(&info->trans_mutex);



		schedule();



		mutex_lock(&info->trans_mutex);

		finish_wait(&info->transaction_wait, &wait);

	}

	mutex_unlock(&info->trans_mutex);

	return 0;

}



/*

 * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on

 * all of them

 */

int btrfs_drop_dead_root(struct btrfs_root *root)

{

	struct btrfs_trans_handle *trans;

	struct btrfs_root *tree_root = root->fs_info->tree_root;

	unsigned long nr;

	int ret;



	while (1) {

		/*

		 * we don't want to jump in and create a bunch of

		 * delayed refs if the transaction is starting to close

		 */

		wait_transaction_pre_flush(tree_root->fs_info);

		trans = btrfs_start_transaction(tree_root, 1);



		/*

		 * we've joined a transaction, make sure it isn't

		 * closing right now

		 */

		if (trans->transaction->delayed_refs.flushing) {

			btrfs_end_transaction(trans, tree_root);

			continue;

		}



		ret = btrfs_drop_snapshot(trans, root);

		if (ret != -EAGAIN)

			break;



		ret = btrfs_update_root(trans, tree_root,

					&root->root_key,

					&root->root_item);

		if (ret)

			break;



		nr = trans->blocks_used;

		ret = btrfs_end_transaction(trans, tree_root);

		BUG_ON(ret);



		btrfs_btree_balance_dirty(tree_root, nr);

		cond_resched();

	}

	BUG_ON(ret);



	ret = btrfs_del_root(trans, tree_root, &root->root_key);

	BUG_ON(ret);



	nr = trans->blocks_used;

	ret = btrfs_end_transaction(trans, tree_root);

	BUG_ON(ret);



	free_extent_buffer(root->node);

	free_extent_buffer(root->commit_root);

	kfree(root);



	btrfs_btree_balance_dirty(tree_root, nr);

	return ret;

}

#endif



/*

 * new snapshots need to be created at a very specific time in the

 * transaction commit.  This does the actual creation