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

Commit b7967db7 authored by Chris Mason's avatar Chris Mason
Browse files

Btrfs: remove #if 0 code 



Btrfs had some old code sitting around under #if 0, this drops it.

Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent d6397bae

fs/btrfs/disk-io.c

+1 −47
Original line number Diff line number Diff line
@@ -584,18 +584,7 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode, 
		btrfs_set_work_high_prio(&async->work);



	btrfs_queue_worker(&fs_info->workers, &async->work);

#if 0

	int limit = btrfs_async_submit_limit(fs_info);

	if (atomic_read(&fs_info->nr_async_submits) > limit) {

		wait_event_timeout(fs_info->async_submit_wait,

			   (atomic_read(&fs_info->nr_async_submits) < limit),

			   HZ/10);



		wait_event_timeout(fs_info->async_submit_wait,

			   (atomic_read(&fs_info->nr_async_bios) < limit),

			   HZ/10);

	}

#endif

	while (atomic_read(&fs_info->async_submit_draining) &&

	      atomic_read(&fs_info->nr_async_submits)) {

		wait_event(fs_info->async_submit_wait,
@@ -770,27 +759,6 @@ static void btree_invalidatepage(struct page *page, unsigned long offset) 
	}

}



#if 0

static int btree_writepage(struct page *page, struct writeback_control *wbc)

{

	struct buffer_head *bh;

	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

	struct buffer_head *head;

	if (!page_has_buffers(page)) {

		create_empty_buffers(page, root->fs_info->sb->s_blocksize,

					(1 << BH_Dirty)|(1 << BH_Uptodate));

	}

	head = page_buffers(page);

	bh = head;

	do {

		if (buffer_dirty(bh))

			csum_tree_block(root, bh, 0);

		bh = bh->b_this_page;

	} while (bh != head);

	return block_write_full_page(page, btree_get_block, wbc);

}

#endif



static struct address_space_operations btree_aops = {

	.readpage	= btree_readpage,

	.writepage	= btree_writepage,
@@ -1278,11 +1246,7 @@ static int btrfs_congested_fn(void *congested_data, int bdi_bits) 
	int ret = 0;

	struct btrfs_device *device;

	struct backing_dev_info *bdi;

#if 0

	if ((bdi_bits & (1 << BDI_write_congested)) &&

	    btrfs_congested_async(info, 0))

		return 1;

#endif



	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {

		if (!device->bdev)

			continue;
@@ -2334,16 +2298,6 @@ int close_ctree(struct btrfs_root *root) 
	btrfs_stop_workers(&fs_info->endio_write_workers);

	btrfs_stop_workers(&fs_info->submit_workers);



#if 0

	while (!list_empty(&fs_info->hashers)) {

		struct btrfs_hasher *hasher;

		hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,

				    hashers);

		list_del(&hasher->hashers);

		crypto_free_hash(&fs_info->hash_tfm);

		kfree(hasher);

	}

#endif

	btrfs_close_devices(fs_info->fs_devices);

	btrfs_mapping_tree_free(&fs_info->mapping_tree);

fs/btrfs/extent_io.c

+0 −63
Original line number Diff line number Diff line
@@ -1401,69 +1401,6 @@ out: 
	return total_bytes;

}



#if 0

/*

 * helper function to lock both pages and extents in the tree.

 * pages must be locked first.

 */

static int lock_range(struct extent_io_tree *tree, u64 start, u64 end)

{

	unsigned long index = start >> PAGE_CACHE_SHIFT;

	unsigned long end_index = end >> PAGE_CACHE_SHIFT;

	struct page *page;

	int err;



	while (index <= end_index) {

		page = grab_cache_page(tree->mapping, index);

		if (!page) {

			err = -ENOMEM;

			goto failed;

		}

		if (IS_ERR(page)) {

			err = PTR_ERR(page);

			goto failed;

		}

		index++;

	}

	lock_extent(tree, start, end, GFP_NOFS);

	return 0;



failed:

	/*

	 * we failed above in getting the page at 'index', so we undo here

	 * up to but not including the page at 'index'

	 */

	end_index = index;

	index = start >> PAGE_CACHE_SHIFT;

	while (index < end_index) {

		page = find_get_page(tree->mapping, index);

		unlock_page(page);

		page_cache_release(page);

		index++;

	}

	return err;

}



/*

 * helper function to unlock both pages and extents in the tree.

 */

static int unlock_range(struct extent_io_tree *tree, u64 start, u64 end)

{

	unsigned long index = start >> PAGE_CACHE_SHIFT;

	unsigned long end_index = end >> PAGE_CACHE_SHIFT;

	struct page *page;



	while (index <= end_index) {

		page = find_get_page(tree->mapping, index);

		unlock_page(page);

		page_cache_release(page);

		index++;

	}

	unlock_extent(tree, start, end, GFP_NOFS);

	return 0;

}

#endif



/*

 * set the private field for a given byte offset in the tree.  If there isn't

 * an extent_state there already, this does nothing.

fs/btrfs/file.c

+0 −78
Original line number Diff line number Diff line
@@ -272,83 +272,6 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 
	return 0;

}



int btrfs_check_file(struct btrfs_root *root, struct inode *inode)

{

	return 0;

#if 0

	struct btrfs_path *path;

	struct btrfs_key found_key;

	struct extent_buffer *leaf;

	struct btrfs_file_extent_item *extent;

	u64 last_offset = 0;

	int nritems;

	int slot;

	int found_type;

	int ret;

	int err = 0;

	u64 extent_end = 0;



	path = btrfs_alloc_path();

	ret = btrfs_lookup_file_extent(NULL, root, path, inode->i_ino,

				       last_offset, 0);

	while (1) {

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

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

			ret = btrfs_next_leaf(root, path);

			if (ret)

				goto out;

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

		}

		slot = path->slots[0];

		leaf = path->nodes[0];

		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != inode->i_ino)

			break;

		if (found_key.type != BTRFS_EXTENT_DATA_KEY)

			goto out;



		if (found_key.offset < last_offset) {

			WARN_ON(1);

			btrfs_print_leaf(root, leaf);

			printk(KERN_ERR "inode %lu found offset %llu "

			       "expected %llu\n", inode->i_ino,

			       (unsigned long long)found_key.offset,

			       (unsigned long long)last_offset);

			err = 1;

			goto out;

		}

		extent = btrfs_item_ptr(leaf, slot,

					struct btrfs_file_extent_item);

		found_type = btrfs_file_extent_type(leaf, extent);

		if (found_type == BTRFS_FILE_EXTENT_REG) {

			extent_end = found_key.offset +

			     btrfs_file_extent_num_bytes(leaf, extent);

		} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {

			struct btrfs_item *item;

			item = btrfs_item_nr(leaf, slot);

			extent_end = found_key.offset +

			     btrfs_file_extent_inline_len(leaf, extent);

			extent_end = (extent_end + root->sectorsize - 1) &

				~((u64)root->sectorsize - 1);

		}

		last_offset = extent_end;

		path->slots[0]++;

	}

	if (0 && last_offset < inode->i_size) {

		WARN_ON(1);

		btrfs_print_leaf(root, leaf);

		printk(KERN_ERR "inode %lu found offset %llu size %llu\n",

		       inode->i_ino, (unsigned long long)last_offset,

		       (unsigned long long)inode->i_size);

		err = 1;



	}

out:

	btrfs_free_path(path);

	return err;

#endif

}



/*

 * this is very complex, but the basic idea is to drop all extents

 * in the range start - end.  hint_block is filled in with a block number
@@ -689,7 +612,6 @@ out: 
		unlock_extent(&BTRFS_I(inode)->io_tree, orig_locked_end,

			      locked_end - 1, GFP_NOFS);

	}

	btrfs_check_file(root, inode);

	return ret;

}