disk-io.c (e18e4809b10e6c9efb5fe10c1ddcb4ebb690d517) disk-io.c (d1310b2e0cd98eb1348553e69b73827b436dca7b)
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,

--- 29 unchanged lines hidden (view full) ---

38 (unsigned long long)extent_buffer_blocknr(buf),
39 (unsigned long long)btrfs_header_blocknr(buf));
40 return 1;
41 }
42 return 0;
43}
44#endif
45
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,

--- 29 unchanged lines hidden (view full) ---

38 (unsigned long long)extent_buffer_blocknr(buf),
39 (unsigned long long)btrfs_header_blocknr(buf));
40 return 1;
41 }
42 return 0;
43}
44#endif
45
46static struct extent_map_ops btree_extent_map_ops;
46static struct extent_io_ops btree_extent_io_ops;
47
48struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
49 u64 bytenr, u32 blocksize)
50{
51 struct inode *btree_inode = root->fs_info->btree_inode;
52 struct extent_buffer *eb;
47
48struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
49 u64 bytenr, u32 blocksize)
50{
51 struct inode *btree_inode = root->fs_info->btree_inode;
52 struct extent_buffer *eb;
53 eb = find_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
53 eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
54 bytenr, blocksize, GFP_NOFS);
55 return eb;
56}
57
58struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
59 u64 bytenr, u32 blocksize)
60{
61 struct inode *btree_inode = root->fs_info->btree_inode;
62 struct extent_buffer *eb;
63
54 bytenr, blocksize, GFP_NOFS);
55 return eb;
56}
57
58struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
59 u64 bytenr, u32 blocksize)
60{
61 struct inode *btree_inode = root->fs_info->btree_inode;
62 struct extent_buffer *eb;
63
64 eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
64 eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
65 bytenr, blocksize, NULL, GFP_NOFS);
66 return eb;
67}
68
69struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
65 bytenr, blocksize, NULL, GFP_NOFS);
66 return eb;
67}
68
69struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
70 size_t page_offset, u64 start, u64 end,
70 size_t page_offset, u64 start, u64 len,
71 int create)
72{
73 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
74 struct extent_map *em;
75 int ret;
76
77again:
71 int create)
72{
73 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
74 struct extent_map *em;
75 int ret;
76
77again:
78 em = lookup_extent_mapping(em_tree, start, end);
78 spin_lock(&em_tree->lock);
79 em = lookup_extent_mapping(em_tree, start, len);
80 spin_unlock(&em_tree->lock);
79 if (em) {
80 goto out;
81 }
82 em = alloc_extent_map(GFP_NOFS);
83 if (!em) {
84 em = ERR_PTR(-ENOMEM);
85 goto out;
86 }
87 em->start = 0;
81 if (em) {
82 goto out;
83 }
84 em = alloc_extent_map(GFP_NOFS);
85 if (!em) {
86 em = ERR_PTR(-ENOMEM);
87 goto out;
88 }
89 em->start = 0;
88 em->end = (i_size_read(inode) & ~((u64)PAGE_CACHE_SIZE -1)) - 1;
90 em->len = i_size_read(inode);
89 em->block_start = 0;
91 em->block_start = 0;
90 em->block_end = em->end;
91 em->bdev = inode->i_sb->s_bdev;
92 em->bdev = inode->i_sb->s_bdev;
93
94 spin_lock(&em_tree->lock);
92 ret = add_extent_mapping(em_tree, em);
95 ret = add_extent_mapping(em_tree, em);
96 spin_unlock(&em_tree->lock);
97
93 if (ret == -EEXIST) {
94 free_extent_map(em);
95 em = NULL;
96 goto again;
97 } else if (ret) {
98 em = ERR_PTR(ret);
99 }
100out:

--- 69 unchanged lines hidden (view full) ---

170 write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
171 }
172 return 0;
173}
174
175
176int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
177{
98 if (ret == -EEXIST) {
99 free_extent_map(em);
100 em = NULL;
101 goto again;
102 } else if (ret) {
103 em = ERR_PTR(ret);
104 }
105out:

--- 69 unchanged lines hidden (view full) ---

175 write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
176 }
177 return 0;
178}
179
180
181int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
182{
178 struct extent_map_tree *tree;
183 struct extent_io_tree *tree;
179 u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
180 u64 found_start;
181 int found_level;
182 unsigned long len;
183 struct extent_buffer *eb;
184 u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
185 u64 found_start;
186 int found_level;
187 unsigned long len;
188 struct extent_buffer *eb;
184 tree = &BTRFS_I(page->mapping->host)->extent_tree;
189 tree = &BTRFS_I(page->mapping->host)->io_tree;
185
186 if (page->private == EXTENT_PAGE_PRIVATE)
187 goto out;
188 if (!page->private)
189 goto out;
190 len = page->private >> 2;
191 if (len == 0) {
192 WARN_ON(1);

--- 32 unchanged lines hidden (view full) ---

225 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
226
227 csum_dirty_buffer(root, page);
228 return 0;
229}
230
231static int btree_writepage(struct page *page, struct writeback_control *wbc)
232{
190
191 if (page->private == EXTENT_PAGE_PRIVATE)
192 goto out;
193 if (!page->private)
194 goto out;
195 len = page->private >> 2;
196 if (len == 0) {
197 WARN_ON(1);

--- 32 unchanged lines hidden (view full) ---

230 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
231
232 csum_dirty_buffer(root, page);
233 return 0;
234}
235
236static int btree_writepage(struct page *page, struct writeback_control *wbc)
237{
233 struct extent_map_tree *tree;
234 tree = &BTRFS_I(page->mapping->host)->extent_tree;
238 struct extent_io_tree *tree;
239 tree = &BTRFS_I(page->mapping->host)->io_tree;
235 return extent_write_full_page(tree, page, btree_get_extent, wbc);
236}
237
238static int btree_writepages(struct address_space *mapping,
239 struct writeback_control *wbc)
240{
240 return extent_write_full_page(tree, page, btree_get_extent, wbc);
241}
242
243static int btree_writepages(struct address_space *mapping,
244 struct writeback_control *wbc)
245{
241 struct extent_map_tree *tree;
242 tree = &BTRFS_I(mapping->host)->extent_tree;
246 struct extent_io_tree *tree;
247 tree = &BTRFS_I(mapping->host)->io_tree;
243 if (wbc->sync_mode == WB_SYNC_NONE) {
244 u64 num_dirty;
245 u64 start = 0;
246 unsigned long thresh = 96 * 1024 * 1024;
247
248 if (wbc->for_kupdate)
249 return 0;
250

--- 8 unchanged lines hidden (view full) ---

259 return 0;
260 }
261 }
262 return extent_writepages(tree, mapping, btree_get_extent, wbc);
263}
264
265int btree_readpage(struct file *file, struct page *page)
266{
248 if (wbc->sync_mode == WB_SYNC_NONE) {
249 u64 num_dirty;
250 u64 start = 0;
251 unsigned long thresh = 96 * 1024 * 1024;
252
253 if (wbc->for_kupdate)
254 return 0;
255

--- 8 unchanged lines hidden (view full) ---

264 return 0;
265 }
266 }
267 return extent_writepages(tree, mapping, btree_get_extent, wbc);
268}
269
270int btree_readpage(struct file *file, struct page *page)
271{
267 struct extent_map_tree *tree;
268 tree = &BTRFS_I(page->mapping->host)->extent_tree;
272 struct extent_io_tree *tree;
273 tree = &BTRFS_I(page->mapping->host)->io_tree;
269 return extent_read_full_page(tree, page, btree_get_extent);
270}
271
272static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
273{
274 return extent_read_full_page(tree, page, btree_get_extent);
275}
276
277static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
278{
274 struct extent_map_tree *tree;
279 struct extent_io_tree *tree;
280 struct extent_map_tree *map;
275 int ret;
276
281 int ret;
282
277 tree = &BTRFS_I(page->mapping->host)->extent_tree;
278 ret = try_release_extent_mapping(tree, page);
283 tree = &BTRFS_I(page->mapping->host)->io_tree;
284 map = &BTRFS_I(page->mapping->host)->extent_tree;
285 ret = try_release_extent_mapping(map, tree, page);
279 if (ret == 1) {
280 ClearPagePrivate(page);
281 set_page_private(page, 0);
282 page_cache_release(page);
283 }
284 return ret;
285}
286
287static void btree_invalidatepage(struct page *page, unsigned long offset)
288{
286 if (ret == 1) {
287 ClearPagePrivate(page);
288 set_page_private(page, 0);
289 page_cache_release(page);
290 }
291 return ret;
292}
293
294static void btree_invalidatepage(struct page *page, unsigned long offset)
295{
289 struct extent_map_tree *tree;
290 tree = &BTRFS_I(page->mapping->host)->extent_tree;
296 struct extent_io_tree *tree;
297 tree = &BTRFS_I(page->mapping->host)->io_tree;
291 extent_invalidatepage(tree, page, offset);
292 btree_releasepage(page, GFP_NOFS);
293}
294
295#if 0
296static int btree_writepage(struct page *page, struct writeback_control *wbc)
297{
298 struct buffer_head *bh;

--- 27 unchanged lines hidden (view full) ---

326{
327 struct extent_buffer *buf = NULL;
328 struct inode *btree_inode = root->fs_info->btree_inode;
329 int ret = 0;
330
331 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
332 if (!buf)
333 return 0;
298 extent_invalidatepage(tree, page, offset);
299 btree_releasepage(page, GFP_NOFS);
300}
301
302#if 0
303static int btree_writepage(struct page *page, struct writeback_control *wbc)
304{
305 struct buffer_head *bh;

--- 27 unchanged lines hidden (view full) ---

333{
334 struct extent_buffer *buf = NULL;
335 struct inode *btree_inode = root->fs_info->btree_inode;
336 int ret = 0;
337
338 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
339 if (!buf)
340 return 0;
334 read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
341 read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
335 buf, 0, 0);
336 free_extent_buffer(buf);
337 return ret;
338}
339
340struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
341 u32 blocksize)
342{
343 struct extent_buffer *buf = NULL;
344 struct inode *btree_inode = root->fs_info->btree_inode;
342 buf, 0, 0);
343 free_extent_buffer(buf);
344 return ret;
345}
346
347struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
348 u32 blocksize)
349{
350 struct extent_buffer *buf = NULL;
351 struct inode *btree_inode = root->fs_info->btree_inode;
345 struct extent_map_tree *extent_tree;
352 struct extent_io_tree *io_tree;
346 u64 end;
347 int ret;
348
353 u64 end;
354 int ret;
355
349 extent_tree = &BTRFS_I(btree_inode)->extent_tree;
356 io_tree = &BTRFS_I(btree_inode)->io_tree;
350
351 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
352 if (!buf)
353 return NULL;
357
358 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
359 if (!buf)
360 return NULL;
354 read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
355 buf, 0, 1);
361 read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree, buf, 0, 1);
356
357 if (buf->flags & EXTENT_CSUM)
358 return buf;
359
360 end = buf->start + PAGE_CACHE_SIZE - 1;
362
363 if (buf->flags & EXTENT_CSUM)
364 return buf;
365
366 end = buf->start + PAGE_CACHE_SIZE - 1;
361 if (test_range_bit(extent_tree, buf->start, end, EXTENT_CSUM, 1)) {
367 if (test_range_bit(io_tree, buf->start, end, EXTENT_CSUM, 1)) {
362 buf->flags |= EXTENT_CSUM;
363 return buf;
364 }
365
368 buf->flags |= EXTENT_CSUM;
369 return buf;
370 }
371
366 lock_extent(extent_tree, buf->start, end, GFP_NOFS);
372 lock_extent(io_tree, buf->start, end, GFP_NOFS);
367
373
368 if (test_range_bit(extent_tree, buf->start, end, EXTENT_CSUM, 1)) {
374 if (test_range_bit(io_tree, buf->start, end, EXTENT_CSUM, 1)) {
369 buf->flags |= EXTENT_CSUM;
370 goto out_unlock;
371 }
372
373 ret = csum_tree_block(root, buf, 1);
375 buf->flags |= EXTENT_CSUM;
376 goto out_unlock;
377 }
378
379 ret = csum_tree_block(root, buf, 1);
374 set_extent_bits(extent_tree, buf->start, end, EXTENT_CSUM, GFP_NOFS);
380 set_extent_bits(io_tree, buf->start, end, EXTENT_CSUM, GFP_NOFS);
375 buf->flags |= EXTENT_CSUM;
376
377out_unlock:
381 buf->flags |= EXTENT_CSUM;
382
383out_unlock:
378 unlock_extent(extent_tree, buf->start, end, GFP_NOFS);
384 unlock_extent(io_tree, buf->start, end, GFP_NOFS);
379 return buf;
380}
381
382int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
383 struct extent_buffer *buf)
384{
385 struct inode *btree_inode = root->fs_info->btree_inode;
386 if (btrfs_header_generation(buf) ==
387 root->fs_info->running_transaction->transid)
385 return buf;
386}
387
388int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
389 struct extent_buffer *buf)
390{
391 struct inode *btree_inode = root->fs_info->btree_inode;
392 if (btrfs_header_generation(buf) ==
393 root->fs_info->running_transaction->transid)
388 clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree,
394 clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
389 buf);
390 return 0;
391}
392
393int wait_on_tree_block_writeback(struct btrfs_root *root,
394 struct extent_buffer *buf)
395{
396 struct inode *btree_inode = root->fs_info->btree_inode;
395 buf);
396 return 0;
397}
398
399int wait_on_tree_block_writeback(struct btrfs_root *root,
400 struct extent_buffer *buf)
401{
402 struct inode *btree_inode = root->fs_info->btree_inode;
397 wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->extent_tree,
403 wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->io_tree,
398 buf);
399 return 0;
400}
401
402static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
403 u32 stripesize, struct btrfs_root *root,
404 struct btrfs_fs_info *fs_info,
405 u64 objectid)

--- 248 unchanged lines hidden (view full) ---

654 fs_info->mount_opt = 0;
655 fs_info->max_extent = (u64)-1;
656 fs_info->delalloc_bytes = 0;
657 fs_info->btree_inode = new_inode(sb);
658 fs_info->btree_inode->i_ino = 1;
659 fs_info->btree_inode->i_nlink = 1;
660 fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
661 fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
404 buf);
405 return 0;
406}
407
408static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
409 u32 stripesize, struct btrfs_root *root,
410 struct btrfs_fs_info *fs_info,
411 u64 objectid)

--- 248 unchanged lines hidden (view full) ---

660 fs_info->mount_opt = 0;
661 fs_info->max_extent = (u64)-1;
662 fs_info->delalloc_bytes = 0;
663 fs_info->btree_inode = new_inode(sb);
664 fs_info->btree_inode->i_ino = 1;
665 fs_info->btree_inode->i_nlink = 1;
666 fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
667 fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
662 extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
668 extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
663 fs_info->btree_inode->i_mapping,
664 GFP_NOFS);
669 fs_info->btree_inode->i_mapping,
670 GFP_NOFS);
665 BTRFS_I(fs_info->btree_inode)->extent_tree.ops = &btree_extent_map_ops;
671 extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
672 GFP_NOFS);
666
673
667 extent_map_tree_init(&fs_info->free_space_cache,
674 BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
675
676 extent_io_tree_init(&fs_info->free_space_cache,
668 fs_info->btree_inode->i_mapping, GFP_NOFS);
677 fs_info->btree_inode->i_mapping, GFP_NOFS);
669 extent_map_tree_init(&fs_info->block_group_cache,
678 extent_io_tree_init(&fs_info->block_group_cache,
670 fs_info->btree_inode->i_mapping, GFP_NOFS);
679 fs_info->btree_inode->i_mapping, GFP_NOFS);
671 extent_map_tree_init(&fs_info->pinned_extents,
680 extent_io_tree_init(&fs_info->pinned_extents,
672 fs_info->btree_inode->i_mapping, GFP_NOFS);
681 fs_info->btree_inode->i_mapping, GFP_NOFS);
673 extent_map_tree_init(&fs_info->pending_del,
682 extent_io_tree_init(&fs_info->pending_del,
674 fs_info->btree_inode->i_mapping, GFP_NOFS);
683 fs_info->btree_inode->i_mapping, GFP_NOFS);
675 extent_map_tree_init(&fs_info->extent_ins,
684 extent_io_tree_init(&fs_info->extent_ins,
676 fs_info->btree_inode->i_mapping, GFP_NOFS);
677 fs_info->do_barriers = 1;
678 fs_info->closing = 0;
679 fs_info->total_pinned = 0;
680 fs_info->last_alloc = 0;
681
682#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
683 INIT_WORK(&fs_info->trans_work, btrfs_transaction_cleaner, fs_info);

--- 98 unchanged lines hidden (view full) ---

782{
783 int ret;
784 struct extent_buffer *super = root->fs_info->sb_buffer;
785 struct inode *btree_inode = root->fs_info->btree_inode;
786 struct super_block *sb = root->fs_info->sb;
787
788 if (!btrfs_test_opt(root, NOBARRIER))
789 blkdev_issue_flush(sb->s_bdev, NULL);
685 fs_info->btree_inode->i_mapping, GFP_NOFS);
686 fs_info->do_barriers = 1;
687 fs_info->closing = 0;
688 fs_info->total_pinned = 0;
689 fs_info->last_alloc = 0;
690
691#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
692 INIT_WORK(&fs_info->trans_work, btrfs_transaction_cleaner, fs_info);

--- 98 unchanged lines hidden (view full) ---

791{
792 int ret;
793 struct extent_buffer *super = root->fs_info->sb_buffer;
794 struct inode *btree_inode = root->fs_info->btree_inode;
795 struct super_block *sb = root->fs_info->sb;
796
797 if (!btrfs_test_opt(root, NOBARRIER))
798 blkdev_issue_flush(sb->s_bdev, NULL);
790 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, super);
799 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, super);
791 ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
792 super->start, super->len);
793 if (!btrfs_test_opt(root, NOBARRIER))
794 blkdev_issue_flush(sb->s_bdev, NULL);
795 return ret;
796}
797
798int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)

--- 60 unchanged lines hidden (view full) ---

859
860 free_extent_buffer(fs_info->sb_buffer);
861
862 btrfs_free_block_groups(root->fs_info);
863 del_fs_roots(fs_info);
864
865 filemap_write_and_wait(fs_info->btree_inode->i_mapping);
866
800 ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
801 super->start, super->len);
802 if (!btrfs_test_opt(root, NOBARRIER))
803 blkdev_issue_flush(sb->s_bdev, NULL);
804 return ret;
805}
806
807int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)

--- 60 unchanged lines hidden (view full) ---

868
869 free_extent_buffer(fs_info->sb_buffer);
870
871 btrfs_free_block_groups(root->fs_info);
872 del_fs_roots(fs_info);
873
874 filemap_write_and_wait(fs_info->btree_inode->i_mapping);
875
867 extent_map_tree_empty_lru(&fs_info->free_space_cache);
868 extent_map_tree_empty_lru(&fs_info->block_group_cache);
869 extent_map_tree_empty_lru(&fs_info->pinned_extents);
870 extent_map_tree_empty_lru(&fs_info->pending_del);
871 extent_map_tree_empty_lru(&fs_info->extent_ins);
872 extent_map_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->extent_tree);
876 extent_io_tree_empty_lru(&fs_info->free_space_cache);
877 extent_io_tree_empty_lru(&fs_info->block_group_cache);
878 extent_io_tree_empty_lru(&fs_info->pinned_extents);
879 extent_io_tree_empty_lru(&fs_info->pending_del);
880 extent_io_tree_empty_lru(&fs_info->extent_ins);
881 extent_io_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->io_tree);
873
874 truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
875
876 iput(fs_info->btree_inode);
877#if 0
878 while(!list_empty(&fs_info->hashers)) {
879 struct btrfs_hasher *hasher;
880 hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,

--- 6 unchanged lines hidden (view full) ---

887 kfree(fs_info->extent_root);
888 kfree(fs_info->tree_root);
889 return 0;
890}
891
892int btrfs_buffer_uptodate(struct extent_buffer *buf)
893{
894 struct inode *btree_inode = buf->first_page->mapping->host;
882
883 truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
884
885 iput(fs_info->btree_inode);
886#if 0
887 while(!list_empty(&fs_info->hashers)) {
888 struct btrfs_hasher *hasher;
889 hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,

--- 6 unchanged lines hidden (view full) ---

896 kfree(fs_info->extent_root);
897 kfree(fs_info->tree_root);
898 return 0;
899}
900
901int btrfs_buffer_uptodate(struct extent_buffer *buf)
902{
903 struct inode *btree_inode = buf->first_page->mapping->host;
895 return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
904 return extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf);
896}
897
898int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
899{
900 struct inode *btree_inode = buf->first_page->mapping->host;
905}
906
907int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
908{
909 struct inode *btree_inode = buf->first_page->mapping->host;
901 return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
910 return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
902 buf);
903}
904
905void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
906{
907 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
908 u64 transid = btrfs_header_generation(buf);
909 struct inode *btree_inode = root->fs_info->btree_inode;
910
911 if (transid != root->fs_info->generation) {
912 printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
913 (unsigned long long)buf->start,
914 transid, root->fs_info->generation);
915 WARN_ON(1);
916 }
911 buf);
912}
913
914void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
915{
916 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
917 u64 transid = btrfs_header_generation(buf);
918 struct inode *btree_inode = root->fs_info->btree_inode;
919
920 if (transid != root->fs_info->generation) {
921 printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
922 (unsigned long long)buf->start,
923 transid, root->fs_info->generation);
924 WARN_ON(1);
925 }
917 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
926 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
918}
919
920void btrfs_throttle(struct btrfs_root *root)
921{
922 struct backing_dev_info *bdi;
923
924 bdi = root->fs_info->sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
925 if (root->fs_info->throttles && bdi_write_congested(bdi)) {

--- 10 unchanged lines hidden (view full) ---

936 balance_dirty_pages_ratelimited_nr(
937 root->fs_info->btree_inode->i_mapping, 1);
938}
939
940void btrfs_set_buffer_defrag(struct extent_buffer *buf)
941{
942 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
943 struct inode *btree_inode = root->fs_info->btree_inode;
927}
928
929void btrfs_throttle(struct btrfs_root *root)
930{
931 struct backing_dev_info *bdi;
932
933 bdi = root->fs_info->sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
934 if (root->fs_info->throttles && bdi_write_congested(bdi)) {

--- 10 unchanged lines hidden (view full) ---

945 balance_dirty_pages_ratelimited_nr(
946 root->fs_info->btree_inode->i_mapping, 1);
947}
948
949void btrfs_set_buffer_defrag(struct extent_buffer *buf)
950{
951 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
952 struct inode *btree_inode = root->fs_info->btree_inode;
944 set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
953 set_extent_bits(&BTRFS_I(btree_inode)->io_tree, buf->start,
945 buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
946}
947
948void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
949{
950 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
951 struct inode *btree_inode = root->fs_info->btree_inode;
954 buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
955}
956
957void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
958{
959 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
960 struct inode *btree_inode = root->fs_info->btree_inode;
952 set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
961 set_extent_bits(&BTRFS_I(btree_inode)->io_tree, buf->start,
953 buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
954 GFP_NOFS);
955}
956
957int btrfs_buffer_defrag(struct extent_buffer *buf)
958{
959 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
960 struct inode *btree_inode = root->fs_info->btree_inode;
962 buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
963 GFP_NOFS);
964}
965
966int btrfs_buffer_defrag(struct extent_buffer *buf)
967{
968 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
969 struct inode *btree_inode = root->fs_info->btree_inode;
961 return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
970 return test_range_bit(&BTRFS_I(btree_inode)->io_tree,
962 buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
963}
964
965int btrfs_buffer_defrag_done(struct extent_buffer *buf)
966{
967 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
968 struct inode *btree_inode = root->fs_info->btree_inode;
971 buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
972}
973
974int btrfs_buffer_defrag_done(struct extent_buffer *buf)
975{
976 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
977 struct inode *btree_inode = root->fs_info->btree_inode;
969 return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
978 return test_range_bit(&BTRFS_I(btree_inode)->io_tree,
970 buf->start, buf->start + buf->len - 1,
971 EXTENT_DEFRAG_DONE, 0);
972}
973
974int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
975{
976 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
977 struct inode *btree_inode = root->fs_info->btree_inode;
979 buf->start, buf->start + buf->len - 1,
980 EXTENT_DEFRAG_DONE, 0);
981}
982
983int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
984{
985 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
986 struct inode *btree_inode = root->fs_info->btree_inode;
978 return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
987 return clear_extent_bits(&BTRFS_I(btree_inode)->io_tree,
979 buf->start, buf->start + buf->len - 1,
980 EXTENT_DEFRAG_DONE, GFP_NOFS);
981}
982
983int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
984{
985 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
986 struct inode *btree_inode = root->fs_info->btree_inode;
988 buf->start, buf->start + buf->len - 1,
989 EXTENT_DEFRAG_DONE, GFP_NOFS);
990}
991
992int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
993{
994 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
995 struct inode *btree_inode = root->fs_info->btree_inode;
987 return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
996 return clear_extent_bits(&BTRFS_I(btree_inode)->io_tree,
988 buf->start, buf->start + buf->len - 1,
989 EXTENT_DEFRAG, GFP_NOFS);
990}
991
992int btrfs_read_buffer(struct extent_buffer *buf)
993{
994 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
995 struct inode *btree_inode = root->fs_info->btree_inode;
997 buf->start, buf->start + buf->len - 1,
998 EXTENT_DEFRAG, GFP_NOFS);
999}
1000
1001int btrfs_read_buffer(struct extent_buffer *buf)
1002{
1003 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1004 struct inode *btree_inode = root->fs_info->btree_inode;
996 return read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
1005 return read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
997 buf, 0, 1);
998}
999
1006 buf, 0, 1);
1007}
1008
1000static struct extent_map_ops btree_extent_map_ops = {
1009static struct extent_io_ops btree_extent_io_ops = {
1001 .writepage_io_hook = btree_writepage_io_hook,
1002};
1010 .writepage_io_hook = btree_writepage_io_hook,
1011};