Btrfs: remove #if 0 code
authorChris Mason <chris.mason@oracle.com>
Mon, 27 Apr 2009 11:29:04 +0000 (07:29 -0400)
committerChris Mason <chris.mason@oracle.com>
Mon, 27 Apr 2009 11:40:52 +0000 (07:40 -0400)
Btrfs had some old code sitting around under #if 0, this drops it.

Signed-off-by: Chris Mason <chris.mason@oracle.com>
fs/btrfs/disk-io.c
fs/btrfs/extent_io.c
fs/btrfs/file.c

index 44c94d808e2b9a1d900c55c03b16960a6fd90081..77f9a3b824bebb5527f6606cb1b3c7ab0d531988 100644 (file)
@@ -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);
 
index c33b54029d785303d598995da3255f8e031a1c3d..fe9eb990e443680ac1920ae1c6aea6327f2ec91e 100644 (file)
@@ -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.
index da3ed965c956a43382f0a2ed4939243ab351ecaf..1d51dc38bb497c3c068520d9d27eb487e1bce6e7 100644 (file)
@@ -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;
 }