Btrfs: remove #if 0 code (b7967db7) · Commits · EulixOS / Software / Kernel

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 @@ u64 count_range_bits(struct extent_io_tree *tree,
		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 @@ noinline int btrfs_drop_extents(struct btrfs_trans_handle *trans,
		unlock_extent(&BTRFS_I(inode)->io_tree, orig_locked_end,
		locked_end - 1, GFP_NOFS);
		}
		btrfs_check_file(root, inode);
		return ret;
		}