2 * Copyright (C) 2007 Oracle. All rights reserved.
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.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
20 #include <linux/blkdev.h>
21 #include <linux/crc32c.h>
22 #include <linux/scatterlist.h>
23 #include <linux/swap.h>
24 #include <linux/radix-tree.h>
25 #include <linux/writeback.h>
26 #include <linux/buffer_head.h> // for block_sync_page
29 #include "transaction.h"
30 #include "btrfs_inode.h"
31 #include "print-tree.h"
34 static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
36 if (extent_buffer_blocknr(buf) != btrfs_header_blocknr(buf)) {
37 printk(KERN_CRIT "buf blocknr(buf) is %llu, header is %llu\n",
38 (unsigned long long)extent_buffer_blocknr(buf),
39 (unsigned long long)btrfs_header_blocknr(buf));
46 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
47 u64 bytenr, u32 blocksize)
49 struct inode *btree_inode = root->fs_info->btree_inode;
50 struct extent_buffer *eb;
51 eb = find_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
52 bytenr, blocksize, GFP_NOFS);
56 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
57 u64 bytenr, u32 blocksize)
59 struct inode *btree_inode = root->fs_info->btree_inode;
60 struct extent_buffer *eb;
62 eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
63 bytenr, blocksize, NULL, GFP_NOFS);
67 struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
68 size_t page_offset, u64 start, u64 end,
71 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
72 struct extent_map *em;
76 em = lookup_extent_mapping(em_tree, start, end);
80 em = alloc_extent_map(GFP_NOFS);
82 em = ERR_PTR(-ENOMEM);
86 em->end = (i_size_read(inode) & ~((u64)PAGE_CACHE_SIZE -1)) - 1;
88 em->block_end = em->end;
89 em->bdev = inode->i_sb->s_bdev;
90 ret = add_extent_mapping(em_tree, em);
102 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
104 return crc32c(seed, data, len);
107 void btrfs_csum_final(u32 crc, char *result)
109 *(__le32 *)result = ~cpu_to_le32(crc);
112 static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
115 char result[BTRFS_CRC32_SIZE];
117 unsigned long cur_len;
118 unsigned long offset = BTRFS_CSUM_SIZE;
119 char *map_token = NULL;
121 unsigned long map_start;
122 unsigned long map_len;
126 len = buf->len - offset;
128 err = map_private_extent_buffer(buf, offset, 32,
130 &map_start, &map_len, KM_USER0);
132 printk("failed to map extent buffer! %lu\n",
136 cur_len = min(len, map_len - (offset - map_start));
137 crc = btrfs_csum_data(root, kaddr + offset - map_start,
141 unmap_extent_buffer(buf, map_token, KM_USER0);
143 btrfs_csum_final(crc, result);
146 if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
147 printk("btrfs: %s checksum verify failed on %llu\n",
148 root->fs_info->sb->s_id,
153 write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
159 int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
161 struct extent_map_tree *tree;
162 u64 start = page->index << PAGE_CACHE_SHIFT;
166 struct extent_buffer *eb;
167 tree = &BTRFS_I(page->mapping->host)->extent_tree;
169 if (page->private == EXTENT_PAGE_PRIVATE)
173 len = page->private >> 2;
177 eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
178 read_extent_buffer_pages(tree, eb, start + PAGE_CACHE_SIZE, 1);
179 found_start = btrfs_header_bytenr(eb);
180 if (found_start != start) {
181 printk("warning: eb start incorrect %Lu buffer %Lu len %lu\n",
182 start, found_start, len);
184 found_level = btrfs_header_level(eb);
185 csum_tree_block(root, eb, 0);
186 free_extent_buffer(eb);
191 static int btree_writepage(struct page *page, struct writeback_control *wbc)
193 struct extent_map_tree *tree;
194 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
195 tree = &BTRFS_I(page->mapping->host)->extent_tree;
197 csum_dirty_buffer(root, page);
198 return extent_write_full_page(tree, page, btree_get_extent, wbc);
200 int btree_readpage(struct file *file, struct page *page)
202 struct extent_map_tree *tree;
203 tree = &BTRFS_I(page->mapping->host)->extent_tree;
204 return extent_read_full_page(tree, page, btree_get_extent);
207 static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
209 struct extent_map_tree *tree;
212 tree = &BTRFS_I(page->mapping->host)->extent_tree;
213 ret = try_release_extent_mapping(tree, page);
215 ClearPagePrivate(page);
216 set_page_private(page, 0);
217 page_cache_release(page);
222 static void btree_invalidatepage(struct page *page, unsigned long offset)
224 struct extent_map_tree *tree;
225 tree = &BTRFS_I(page->mapping->host)->extent_tree;
226 extent_invalidatepage(tree, page, offset);
227 btree_releasepage(page, GFP_NOFS);
231 static int btree_writepage(struct page *page, struct writeback_control *wbc)
233 struct buffer_head *bh;
234 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
235 struct buffer_head *head;
236 if (!page_has_buffers(page)) {
237 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
238 (1 << BH_Dirty)|(1 << BH_Uptodate));
240 head = page_buffers(page);
243 if (buffer_dirty(bh))
244 csum_tree_block(root, bh, 0);
245 bh = bh->b_this_page;
246 } while (bh != head);
247 return block_write_full_page(page, btree_get_block, wbc);
251 static struct address_space_operations btree_aops = {
252 .readpage = btree_readpage,
253 .writepage = btree_writepage,
254 .releasepage = btree_releasepage,
255 .invalidatepage = btree_invalidatepage,
256 .sync_page = block_sync_page,
259 int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
261 struct extent_buffer *buf = NULL;
262 struct inode *btree_inode = root->fs_info->btree_inode;
265 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
268 read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
270 free_extent_buffer(buf);
274 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
277 struct extent_buffer *buf = NULL;
278 struct inode *btree_inode = root->fs_info->btree_inode;
279 struct extent_map_tree *extent_tree;
282 extent_tree = &BTRFS_I(btree_inode)->extent_tree;
284 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
287 read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
289 if (buf->flags & EXTENT_CSUM) {
292 if (test_range_bit(extent_tree, buf->start, buf->start + buf->len - 1,
294 buf->flags |= EXTENT_CSUM;
297 ret = csum_tree_block(root, buf, 1);
298 set_extent_bits(extent_tree, buf->start,
299 buf->start + buf->len - 1,
300 EXTENT_CSUM, GFP_NOFS);
301 buf->flags |= EXTENT_CSUM;
305 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
306 struct extent_buffer *buf)
308 struct inode *btree_inode = root->fs_info->btree_inode;
309 clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
313 int wait_on_tree_block_writeback(struct btrfs_root *root,
314 struct extent_buffer *buf)
316 struct inode *btree_inode = root->fs_info->btree_inode;
317 wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->extent_tree,
322 static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
323 struct btrfs_root *root,
324 struct btrfs_fs_info *fs_info,
329 root->commit_root = NULL;
330 root->sectorsize = sectorsize;
331 root->nodesize = nodesize;
332 root->leafsize = leafsize;
334 root->fs_info = fs_info;
335 root->objectid = objectid;
336 root->last_trans = 0;
337 root->highest_inode = 0;
338 root->last_inode_alloc = 0;
340 memset(&root->root_key, 0, sizeof(root->root_key));
341 memset(&root->root_item, 0, sizeof(root->root_item));
342 memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
343 memset(&root->root_kobj, 0, sizeof(root->root_kobj));
344 init_completion(&root->kobj_unregister);
345 init_rwsem(&root->snap_sem);
346 root->defrag_running = 0;
347 root->defrag_level = 0;
348 root->root_key.objectid = objectid;
352 static int find_and_setup_root(struct btrfs_root *tree_root,
353 struct btrfs_fs_info *fs_info,
355 struct btrfs_root *root)
360 __setup_root(tree_root->nodesize, tree_root->leafsize,
361 tree_root->sectorsize, root, fs_info, objectid);
362 ret = btrfs_find_last_root(tree_root, objectid,
363 &root->root_item, &root->root_key);
366 blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
367 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
373 struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
374 struct btrfs_key *location)
376 struct btrfs_root *root;
377 struct btrfs_root *tree_root = fs_info->tree_root;
378 struct btrfs_path *path;
379 struct extent_buffer *l;
384 root = kzalloc(sizeof(*root), GFP_NOFS);
386 return ERR_PTR(-ENOMEM);
387 if (location->offset == (u64)-1) {
388 ret = find_and_setup_root(tree_root, fs_info,
389 location->objectid, root);
397 __setup_root(tree_root->nodesize, tree_root->leafsize,
398 tree_root->sectorsize, root, fs_info,
401 path = btrfs_alloc_path();
403 ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
410 read_extent_buffer(l, &root->root_item,
411 btrfs_item_ptr_offset(l, path->slots[0]),
412 sizeof(root->root_item));
413 memcpy(&root->root_key, location, sizeof(*location));
416 btrfs_release_path(root, path);
417 btrfs_free_path(path);
422 blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
423 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
428 ret = btrfs_find_highest_inode(root, &highest_inode);
430 root->highest_inode = highest_inode;
431 root->last_inode_alloc = highest_inode;
436 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
437 struct btrfs_key *location,
438 const char *name, int namelen)
440 struct btrfs_root *root;
443 root = radix_tree_lookup(&fs_info->fs_roots_radix,
444 (unsigned long)location->objectid);
448 root = btrfs_read_fs_root_no_radix(fs_info, location);
451 ret = radix_tree_insert(&fs_info->fs_roots_radix,
452 (unsigned long)root->root_key.objectid,
455 free_extent_buffer(root->node);
460 ret = btrfs_set_root_name(root, name, namelen);
462 free_extent_buffer(root->node);
467 ret = btrfs_sysfs_add_root(root);
469 free_extent_buffer(root->node);
475 ret = btrfs_find_dead_roots(fs_info->tree_root,
476 root->root_key.objectid, root);
482 static int add_hasher(struct btrfs_fs_info *info, char *type) {
483 struct btrfs_hasher *hasher;
485 hasher = kmalloc(sizeof(*hasher), GFP_NOFS);
488 hasher->hash_tfm = crypto_alloc_hash(type, 0, CRYPTO_ALG_ASYNC);
489 if (!hasher->hash_tfm) {
493 spin_lock(&info->hash_lock);
494 list_add(&hasher->list, &info->hashers);
495 spin_unlock(&info->hash_lock);
499 struct btrfs_root *open_ctree(struct super_block *sb)
505 struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
507 struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
509 struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
513 struct btrfs_super_block *disk_super;
515 if (!extent_root || !tree_root || !fs_info) {
519 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
520 INIT_LIST_HEAD(&fs_info->trans_list);
521 INIT_LIST_HEAD(&fs_info->dead_roots);
522 INIT_LIST_HEAD(&fs_info->hashers);
523 spin_lock_init(&fs_info->hash_lock);
525 memset(&fs_info->super_kobj, 0, sizeof(fs_info->super_kobj));
526 init_completion(&fs_info->kobj_unregister);
527 sb_set_blocksize(sb, 4096);
528 fs_info->running_transaction = NULL;
529 fs_info->last_trans_committed = 0;
530 fs_info->tree_root = tree_root;
531 fs_info->extent_root = extent_root;
533 fs_info->btree_inode = new_inode(sb);
534 fs_info->btree_inode->i_ino = 1;
535 fs_info->btree_inode->i_nlink = 1;
536 fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
537 fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
538 extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
539 fs_info->btree_inode->i_mapping,
541 extent_map_tree_init(&fs_info->free_space_cache,
542 fs_info->btree_inode->i_mapping, GFP_NOFS);
543 extent_map_tree_init(&fs_info->block_group_cache,
544 fs_info->btree_inode->i_mapping, GFP_NOFS);
545 extent_map_tree_init(&fs_info->pinned_extents,
546 fs_info->btree_inode->i_mapping, GFP_NOFS);
547 extent_map_tree_init(&fs_info->pending_del,
548 fs_info->btree_inode->i_mapping, GFP_NOFS);
549 extent_map_tree_init(&fs_info->extent_ins,
550 fs_info->btree_inode->i_mapping, GFP_NOFS);
551 fs_info->do_barriers = 1;
552 fs_info->closing = 0;
554 INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
555 BTRFS_I(fs_info->btree_inode)->root = tree_root;
556 memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
557 sizeof(struct btrfs_key));
558 insert_inode_hash(fs_info->btree_inode);
559 mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
561 mutex_init(&fs_info->trans_mutex);
562 mutex_init(&fs_info->fs_mutex);
565 ret = add_hasher(fs_info, "crc32c");
567 printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
572 __setup_root(512, 512, 512, tree_root,
573 fs_info, BTRFS_ROOT_TREE_OBJECTID);
575 fs_info->sb_buffer = read_tree_block(tree_root,
576 BTRFS_SUPER_INFO_OFFSET,
579 if (!fs_info->sb_buffer)
582 read_extent_buffer(fs_info->sb_buffer, &fs_info->super_copy, 0,
583 sizeof(fs_info->super_copy));
585 read_extent_buffer(fs_info->sb_buffer, fs_info->fsid,
586 (unsigned long)btrfs_super_fsid(fs_info->sb_buffer),
588 disk_super = &fs_info->super_copy;
589 if (!btrfs_super_root(disk_super))
592 nodesize = btrfs_super_nodesize(disk_super);
593 leafsize = btrfs_super_leafsize(disk_super);
594 sectorsize = btrfs_super_sectorsize(disk_super);
595 tree_root->nodesize = nodesize;
596 tree_root->leafsize = leafsize;
597 tree_root->sectorsize = sectorsize;
598 sb_set_blocksize(sb, sectorsize);
600 i_size_write(fs_info->btree_inode,
601 btrfs_super_total_bytes(disk_super));
603 if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
604 sizeof(disk_super->magic))) {
605 printk("btrfs: valid FS not found on %s\n", sb->s_id);
609 blocksize = btrfs_level_size(tree_root,
610 btrfs_super_root_level(disk_super));
612 tree_root->node = read_tree_block(tree_root,
613 btrfs_super_root(disk_super),
615 if (!tree_root->node)
618 mutex_lock(&fs_info->fs_mutex);
620 ret = find_and_setup_root(tree_root, fs_info,
621 BTRFS_EXTENT_TREE_OBJECTID, extent_root);
623 mutex_unlock(&fs_info->fs_mutex);
627 btrfs_read_block_groups(extent_root);
629 fs_info->generation = btrfs_super_generation(disk_super) + 1;
630 mutex_unlock(&fs_info->fs_mutex);
634 free_extent_buffer(tree_root->node);
636 free_extent_buffer(fs_info->sb_buffer);
638 iput(fs_info->btree_inode);
646 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
650 struct extent_buffer *super = root->fs_info->sb_buffer;
651 struct inode *btree_inode = root->fs_info->btree_inode;
653 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, super);
654 ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
655 super->start, super->len);
659 int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
661 radix_tree_delete(&fs_info->fs_roots_radix,
662 (unsigned long)root->root_key.objectid);
663 btrfs_sysfs_del_root(root);
667 free_extent_buffer(root->node);
668 if (root->commit_root)
669 free_extent_buffer(root->commit_root);
676 static int del_fs_roots(struct btrfs_fs_info *fs_info)
679 struct btrfs_root *gang[8];
683 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
688 for (i = 0; i < ret; i++)
689 btrfs_free_fs_root(fs_info, gang[i]);
694 int close_ctree(struct btrfs_root *root)
697 struct btrfs_trans_handle *trans;
698 struct btrfs_fs_info *fs_info = root->fs_info;
700 fs_info->closing = 1;
701 btrfs_transaction_flush_work(root);
702 mutex_lock(&fs_info->fs_mutex);
703 btrfs_defrag_dirty_roots(root->fs_info);
704 trans = btrfs_start_transaction(root, 1);
705 ret = btrfs_commit_transaction(trans, root);
706 /* run commit again to drop the original snapshot */
707 trans = btrfs_start_transaction(root, 1);
708 btrfs_commit_transaction(trans, root);
709 ret = btrfs_write_and_wait_transaction(NULL, root);
711 write_ctree_super(NULL, root);
712 mutex_unlock(&fs_info->fs_mutex);
714 if (fs_info->extent_root->node)
715 free_extent_buffer(fs_info->extent_root->node);
717 if (fs_info->tree_root->node)
718 free_extent_buffer(fs_info->tree_root->node);
720 free_extent_buffer(fs_info->sb_buffer);
722 btrfs_free_block_groups(root->fs_info);
723 del_fs_roots(fs_info);
724 extent_map_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->extent_tree);
725 truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
726 iput(fs_info->btree_inode);
728 while(!list_empty(&fs_info->hashers)) {
729 struct btrfs_hasher *hasher;
730 hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,
732 list_del(&hasher->hashers);
733 crypto_free_hash(&fs_info->hash_tfm);
737 kfree(fs_info->extent_root);
738 kfree(fs_info->tree_root);
742 int btrfs_buffer_uptodate(struct extent_buffer *buf)
744 struct inode *btree_inode = buf->first_page->mapping->host;
745 return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
748 int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
750 struct inode *btree_inode = buf->first_page->mapping->host;
751 return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
755 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
757 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
758 u64 transid = btrfs_header_generation(buf);
759 struct inode *btree_inode = root->fs_info->btree_inode;
761 if (transid != root->fs_info->generation) {
762 printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
763 (unsigned long long)buf->start,
764 transid, root->fs_info->generation);
767 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
770 void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
772 balance_dirty_pages_ratelimited_nr(
773 root->fs_info->btree_inode->i_mapping, 1);
776 void btrfs_set_buffer_defrag(struct extent_buffer *buf)
778 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
779 struct inode *btree_inode = root->fs_info->btree_inode;
780 set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
781 buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
784 void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
786 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
787 struct inode *btree_inode = root->fs_info->btree_inode;
788 set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
789 buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
793 int btrfs_buffer_defrag(struct extent_buffer *buf)
795 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
796 struct inode *btree_inode = root->fs_info->btree_inode;
797 return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
798 buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
801 int btrfs_buffer_defrag_done(struct extent_buffer *buf)
803 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
804 struct inode *btree_inode = root->fs_info->btree_inode;
805 return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
806 buf->start, buf->start + buf->len - 1,
807 EXTENT_DEFRAG_DONE, 0);
810 int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
812 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
813 struct inode *btree_inode = root->fs_info->btree_inode;
814 return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
815 buf->start, buf->start + buf->len - 1,
816 EXTENT_DEFRAG_DONE, GFP_NOFS);
819 int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
821 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
822 struct inode *btree_inode = root->fs_info->btree_inode;
823 return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
824 buf->start, buf->start + buf->len - 1,
825 EXTENT_DEFRAG, GFP_NOFS);
828 int btrfs_read_buffer(struct extent_buffer *buf)
830 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
831 struct inode *btree_inode = root->fs_info->btree_inode;
832 return read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,