mirror of
https://github.com/adulau/aha.git
synced 2024-12-28 11:46:19 +00:00
Btrfs: remove #if 0 code
Btrfs had some old code sitting around under #if 0, this drops it. Signed-off-by: Chris Mason <chris.mason@oracle.com>
This commit is contained in:
Chris Mason
parent
d6397baee4
commit
b7967db75a
3 changed files with 1 additions and 188 deletions
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue