projects / deliverable / linux.git / blob
? search:


eebb4fb65c61cf414a96089b0ee587fc13d92cd9
[deliverable/linux.git] / fs / btrfs / disk-io.c
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,
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.
12 *
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.
17 */
18
19 #include <linux/fs.h>
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
27 #include "ctree.h"
28 #include "disk-io.h"
29 #include "transaction.h"
30 #include "btrfs_inode.h"
31 #include "print-tree.h"
32
33 #if 0
34 static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
35 {
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));
40 return 1;
41 }
42 return 0;
43 }
44 #endif
45
46 static struct extent_map_ops btree_extent_map_ops;
47
48 struct 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,
54 bytenr, blocksize, GFP_NOFS);
55 return eb;
56 }
57
58 struct 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,
65 bytenr, blocksize, NULL, GFP_NOFS);
66 return eb;
67 }
68
69 struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
70 size_t page_offset, u64 start, u64 end,
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
77 again:
78 em = lookup_extent_mapping(em_tree, start, end);
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;
88 em->end = (i_size_read(inode) & ~((u64)PAGE_CACHE_SIZE -1)) - 1;
89 em->block_start = 0;
90 em->block_end = em->end;
91 em->bdev = inode->i_sb->s_bdev;
92 ret = add_extent_mapping(em_tree, em);
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 }
100 out:
101 return em;
102 }
103
104 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
105 {
106 return crc32c(seed, data, len);
107 }
108
109 void btrfs_csum_final(u32 crc, char *result)
110 {
111 *(__le32 *)result = ~cpu_to_le32(crc);
112 }
113
114 static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
115 int verify)
116 {
117 char result[BTRFS_CRC32_SIZE];
118 unsigned long len;
119 unsigned long cur_len;
120 unsigned long offset = BTRFS_CSUM_SIZE;
121 char *map_token = NULL;
122 char *kaddr;
123 unsigned long map_start;
124 unsigned long map_len;
125 int err;
126 u32 crc = ~(u32)0;
127
128 len = buf->len - offset;
129 while(len > 0) {
130 err = map_private_extent_buffer(buf, offset, 32,
131 &map_token, &kaddr,
132 &map_start, &map_len, KM_USER0);
133 if (err) {
134 printk("failed to map extent buffer! %lu\n",
135 offset);
136 return 1;
137 }
138 cur_len = min(len, map_len - (offset - map_start));
139 crc = btrfs_csum_data(root, kaddr + offset - map_start,
140 crc, cur_len);
141 len -= cur_len;
142 offset += cur_len;
143 unmap_extent_buffer(buf, map_token, KM_USER0);
144 }
145 btrfs_csum_final(crc, result);
146
147 if (verify) {
148 if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
149 printk("btrfs: %s checksum verify failed on %llu\n",
150 root->fs_info->sb->s_id,
151 buf->start);
152 return 1;
153 }
154 } else {
155 write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
156 }
157 return 0;
158 }
159
160
161 int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
162 {
163 struct extent_map_tree *tree;
164 u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
165 u64 found_start;
166 int found_level;
167 unsigned long len;
168 struct extent_buffer *eb;
169 tree = &BTRFS_I(page->mapping->host)->extent_tree;
170
171 if (page->private == EXTENT_PAGE_PRIVATE)
172 goto out;
173 if (!page->private)
174 goto out;
175 len = page->private >> 2;
176 if (len == 0) {
177 WARN_ON(1);
178 }
179 eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
180 read_extent_buffer_pages(tree, eb, start + PAGE_CACHE_SIZE, 1);
181 found_start = btrfs_header_bytenr(eb);
182 if (found_start != start) {
183 printk("warning: eb start incorrect %Lu buffer %Lu len %lu\n",
184 start, found_start, len);
185 }
186 found_level = btrfs_header_level(eb);
187 csum_tree_block(root, eb, 0);
188 free_extent_buffer(eb);
189 out:
190 return 0;
191 }
192
193 static int btree_writepage_io_hook(struct page *page, u64 start, u64 end)
194 {
195 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
196
197 csum_dirty_buffer(root, page);
198 return 0;
199 }
200
201 static int btree_writepage(struct page *page, struct writeback_control *wbc)
202 {
203 struct extent_map_tree *tree;
204 tree = &BTRFS_I(page->mapping->host)->extent_tree;
205 return extent_write_full_page(tree, page, btree_get_extent, wbc);
206 }
207
208 static int btree_writepages(struct address_space *mapping,
209 struct writeback_control *wbc)
210 {
211 struct extent_map_tree *tree;
212 tree = &BTRFS_I(mapping->host)->extent_tree;
213 if (wbc->sync_mode == WB_SYNC_NONE) {
214 u64 num_dirty;
215 u64 start = 0;
216 unsigned long thresh = 96 * 1024 * 1024;
217
218 if (wbc->for_kupdate)
219 return 0;
220
221 if (current_is_pdflush()) {
222 thresh = 96 * 1024 * 1024;
223 } else {
224 thresh = 8 * 1024 * 1024;
225 }
226 num_dirty = count_range_bits(tree, &start, (u64)-1,
227 thresh, EXTENT_DIRTY);
228 if (num_dirty < thresh) {
229 return 0;
230 }
231 }
232 return extent_writepages(tree, mapping, btree_get_extent, wbc);
233 }
234
235 int btree_readpage(struct file *file, struct page *page)
236 {
237 struct extent_map_tree *tree;
238 tree = &BTRFS_I(page->mapping->host)->extent_tree;
239 return extent_read_full_page(tree, page, btree_get_extent);
240 }
241
242 static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
243 {
244 struct extent_map_tree *tree;
245 int ret;
246
247 tree = &BTRFS_I(page->mapping->host)->extent_tree;
248 ret = try_release_extent_mapping(tree, page);
249 if (ret == 1) {
250 ClearPagePrivate(page);
251 set_page_private(page, 0);
252 page_cache_release(page);
253 }
254 return ret;
255 }
256
257 static void btree_invalidatepage(struct page *page, unsigned long offset)
258 {
259 struct extent_map_tree *tree;
260 tree = &BTRFS_I(page->mapping->host)->extent_tree;
261 extent_invalidatepage(tree, page, offset);
262 btree_releasepage(page, GFP_NOFS);
263 }
264
265 #if 0
266 static int btree_writepage(struct page *page, struct writeback_control *wbc)
267 {
268 struct buffer_head *bh;
269 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
270 struct buffer_head *head;
271 if (!page_has_buffers(page)) {
272 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
273 (1 << BH_Dirty)|(1 << BH_Uptodate));
274 }
275 head = page_buffers(page);
276 bh = head;
277 do {
278 if (buffer_dirty(bh))
279 csum_tree_block(root, bh, 0);
280 bh = bh->b_this_page;
281 } while (bh != head);
282 return block_write_full_page(page, btree_get_block, wbc);
283 }
284 #endif
285
286 static struct address_space_operations btree_aops = {
287 .readpage = btree_readpage,
288 .writepage = btree_writepage,
289 .writepages = btree_writepages,
290 .releasepage = btree_releasepage,
291 .invalidatepage = btree_invalidatepage,
292 .sync_page = block_sync_page,
293 };
294
295 int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
296 {
297 struct extent_buffer *buf = NULL;
298 struct inode *btree_inode = root->fs_info->btree_inode;
299 int ret = 0;
300
301 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
302 if (!buf)
303 return 0;
304 read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
305 buf, 0, 0);
306 free_extent_buffer(buf);
307 return ret;
308 }
309
310 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
311 u32 blocksize)
312 {
313 struct extent_buffer *buf = NULL;
314 struct inode *btree_inode = root->fs_info->btree_inode;
315 struct extent_map_tree *extent_tree;
316 int ret;
317
318 extent_tree = &BTRFS_I(btree_inode)->extent_tree;
319
320 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
321 if (!buf)
322 return NULL;
323 read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
324 buf, 0, 1);
325 if (buf->flags & EXTENT_CSUM) {
326 return buf;
327 }
328 if (test_range_bit(extent_tree, buf->start, buf->start + buf->len - 1,
329 EXTENT_CSUM, 1)) {
330 buf->flags |= EXTENT_CSUM;
331 return buf;
332 }
333 ret = csum_tree_block(root, buf, 1);
334 set_extent_bits(extent_tree, buf->start,
335 buf->start + buf->len - 1,
336 EXTENT_CSUM, GFP_NOFS);
337 buf->flags |= EXTENT_CSUM;
338 return buf;
339 }
340
341 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
342 struct extent_buffer *buf)
343 {
344 struct inode *btree_inode = root->fs_info->btree_inode;
345 clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
346 return 0;
347 }
348
349 int wait_on_tree_block_writeback(struct btrfs_root *root,
350 struct extent_buffer *buf)
351 {
352 struct inode *btree_inode = root->fs_info->btree_inode;
353 wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->extent_tree,
354 buf);
355 return 0;
356 }
357
358 static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
359 u32 stripesize, struct btrfs_root *root,
360 struct btrfs_fs_info *fs_info,
361 u64 objectid)
362 {
363 root->node = NULL;
364 root->inode = NULL;
365 root->commit_root = NULL;
366 root->sectorsize = sectorsize;
367 root->nodesize = nodesize;
368 root->leafsize = leafsize;
369 root->stripesize = stripesize;
370 root->ref_cows = 0;
371 root->fs_info = fs_info;
372 root->objectid = objectid;
373 root->last_trans = 0;
374 root->highest_inode = 0;
375 root->last_inode_alloc = 0;
376 root->name = NULL;
377 memset(&root->root_key, 0, sizeof(root->root_key));
378 memset(&root->root_item, 0, sizeof(root->root_item));
379 memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
380 memset(&root->root_kobj, 0, sizeof(root->root_kobj));
381 init_completion(&root->kobj_unregister);
382 init_rwsem(&root->snap_sem);
383 root->defrag_running = 0;
384 root->defrag_level = 0;
385 root->root_key.objectid = objectid;
386 return 0;
387 }
388
389 static int find_and_setup_root(struct btrfs_root *tree_root,
390 struct btrfs_fs_info *fs_info,
391 u64 objectid,
392 struct btrfs_root *root)
393 {
394 int ret;
395 u32 blocksize;
396
397 __setup_root(tree_root->nodesize, tree_root->leafsize,
398 tree_root->sectorsize, tree_root->stripesize,
399 root, fs_info, objectid);
400 ret = btrfs_find_last_root(tree_root, objectid,
401 &root->root_item, &root->root_key);
402 BUG_ON(ret);
403
404 blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
405 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
406 blocksize);
407 BUG_ON(!root->node);
408 return 0;
409 }
410
411 struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
412 struct btrfs_key *location)
413 {
414 struct btrfs_root *root;
415 struct btrfs_root *tree_root = fs_info->tree_root;
416 struct btrfs_path *path;
417 struct extent_buffer *l;
418 u64 highest_inode;
419 u32 blocksize;
420 int ret = 0;
421
422 root = kzalloc(sizeof(*root), GFP_NOFS);
423 if (!root)
424 return ERR_PTR(-ENOMEM);
425 if (location->offset == (u64)-1) {
426 ret = find_and_setup_root(tree_root, fs_info,
427 location->objectid, root);
428 if (ret) {
429 kfree(root);
430 return ERR_PTR(ret);
431 }
432 goto insert;
433 }
434
435 __setup_root(tree_root->nodesize, tree_root->leafsize,
436 tree_root->sectorsize, tree_root->stripesize,
437 root, fs_info, location->objectid);
438
439 path = btrfs_alloc_path();
440 BUG_ON(!path);
441 ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
442 if (ret != 0) {
443 if (ret > 0)
444 ret = -ENOENT;
445 goto out;
446 }
447 l = path->nodes[0];
448 read_extent_buffer(l, &root->root_item,
449 btrfs_item_ptr_offset(l, path->slots[0]),
450 sizeof(root->root_item));
451 memcpy(&root->root_key, location, sizeof(*location));
452 ret = 0;
453 out:
454 btrfs_release_path(root, path);
455 btrfs_free_path(path);
456 if (ret) {
457 kfree(root);
458 return ERR_PTR(ret);
459 }
460 blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
461 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
462 blocksize);
463 BUG_ON(!root->node);
464 insert:
465 root->ref_cows = 1;
466 ret = btrfs_find_highest_inode(root, &highest_inode);
467 if (ret == 0) {
468 root->highest_inode = highest_inode;
469 root->last_inode_alloc = highest_inode;
470 }
471 return root;
472 }
473
474 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
475 struct btrfs_key *location,
476 const char *name, int namelen)
477 {
478 struct btrfs_root *root;
479 int ret;
480
481 root = radix_tree_lookup(&fs_info->fs_roots_radix,
482 (unsigned long)location->objectid);
483 if (root)
484 return root;
485
486 root = btrfs_read_fs_root_no_radix(fs_info, location);
487 if (IS_ERR(root))
488 return root;
489 ret = radix_tree_insert(&fs_info->fs_roots_radix,
490 (unsigned long)root->root_key.objectid,
491 root);
492 if (ret) {
493 free_extent_buffer(root->node);
494 kfree(root);
495 return ERR_PTR(ret);
496 }
497
498 ret = btrfs_set_root_name(root, name, namelen);
499 if (ret) {
500 free_extent_buffer(root->node);
501 kfree(root);
502 return ERR_PTR(ret);
503 }
504
505 ret = btrfs_sysfs_add_root(root);
506 if (ret) {
507 free_extent_buffer(root->node);
508 kfree(root->name);
509 kfree(root);
510 return ERR_PTR(ret);
511 }
512
513 ret = btrfs_find_dead_roots(fs_info->tree_root,
514 root->root_key.objectid, root);
515 BUG_ON(ret);
516
517 return root;
518 }
519 #if 0
520 static int add_hasher(struct btrfs_fs_info *info, char *type) {
521 struct btrfs_hasher *hasher;
522
523 hasher = kmalloc(sizeof(*hasher), GFP_NOFS);
524 if (!hasher)
525 return -ENOMEM;
526 hasher->hash_tfm = crypto_alloc_hash(type, 0, CRYPTO_ALG_ASYNC);
527 if (!hasher->hash_tfm) {
528 kfree(hasher);
529 return -EINVAL;
530 }
531 spin_lock(&info->hash_lock);
532 list_add(&hasher->list, &info->hashers);
533 spin_unlock(&info->hash_lock);
534 return 0;
535 }
536 #endif
537 struct btrfs_root *open_ctree(struct super_block *sb)
538 {
539 u32 sectorsize;
540 u32 nodesize;
541 u32 leafsize;
542 u32 blocksize;
543 u32 stripesize;
544 struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
545 GFP_NOFS);
546 struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
547 GFP_NOFS);
548 struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
549 GFP_NOFS);
550 int ret;
551 int err = -EIO;
552 struct btrfs_super_block *disk_super;
553
554 if (!extent_root || !tree_root || !fs_info) {
555 err = -ENOMEM;
556 goto fail;
557 }
558 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
559 INIT_LIST_HEAD(&fs_info->trans_list);
560 INIT_LIST_HEAD(&fs_info->dead_roots);
561 INIT_LIST_HEAD(&fs_info->hashers);
562 spin_lock_init(&fs_info->hash_lock);
563 spin_lock_init(&fs_info->delalloc_lock);
564
565 memset(&fs_info->super_kobj, 0, sizeof(fs_info->super_kobj));
566 init_completion(&fs_info->kobj_unregister);
567 sb_set_blocksize(sb, 4096);
568 fs_info->running_transaction = NULL;
569 fs_info->last_trans_committed = 0;
570 fs_info->tree_root = tree_root;
571 fs_info->extent_root = extent_root;
572 fs_info->sb = sb;
573 fs_info->mount_opt = 0;
574 fs_info->max_extent = (u64)-1;
575 fs_info->delalloc_bytes = 0;
576 fs_info->btree_inode = new_inode(sb);
577 fs_info->btree_inode->i_ino = 1;
578 fs_info->btree_inode->i_nlink = 1;
579 fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
580 fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
581 extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
582 fs_info->btree_inode->i_mapping,
583 GFP_NOFS);
584 BTRFS_I(fs_info->btree_inode)->extent_tree.ops = &btree_extent_map_ops;
585
586 extent_map_tree_init(&fs_info->free_space_cache,
587 fs_info->btree_inode->i_mapping, GFP_NOFS);
588 extent_map_tree_init(&fs_info->block_group_cache,
589 fs_info->btree_inode->i_mapping, GFP_NOFS);
590 extent_map_tree_init(&fs_info->pinned_extents,
591 fs_info->btree_inode->i_mapping, GFP_NOFS);
592 extent_map_tree_init(&fs_info->pending_del,
593 fs_info->btree_inode->i_mapping, GFP_NOFS);
594 extent_map_tree_init(&fs_info->extent_ins,
595 fs_info->btree_inode->i_mapping, GFP_NOFS);
596 fs_info->do_barriers = 1;
597 fs_info->closing = 0;
598 fs_info->total_pinned = 0;
599 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
600 INIT_WORK(&fs_info->trans_work, btrfs_transaction_cleaner, fs_info);
601 #else
602 INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
603 #endif
604 BTRFS_I(fs_info->btree_inode)->root = tree_root;
605 memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
606 sizeof(struct btrfs_key));
607 insert_inode_hash(fs_info->btree_inode);
608 mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
609
610 mutex_init(&fs_info->trans_mutex);
611 mutex_init(&fs_info->fs_mutex);
612
613 #if 0
614 ret = add_hasher(fs_info, "crc32c");
615 if (ret) {
616 printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
617 err = -ENOMEM;
618 goto fail_iput;
619 }
620 #endif
621 __setup_root(512, 512, 512, 512, tree_root,
622 fs_info, BTRFS_ROOT_TREE_OBJECTID);
623
624 fs_info->sb_buffer = read_tree_block(tree_root,
625 BTRFS_SUPER_INFO_OFFSET,
626 512);
627
628 if (!fs_info->sb_buffer)
629 goto fail_iput;
630
631 read_extent_buffer(fs_info->sb_buffer, &fs_info->super_copy, 0,
632 sizeof(fs_info->super_copy));
633
634 read_extent_buffer(fs_info->sb_buffer, fs_info->fsid,
635 (unsigned long)btrfs_super_fsid(fs_info->sb_buffer),
636 BTRFS_FSID_SIZE);
637 disk_super = &fs_info->super_copy;
638 if (!btrfs_super_root(disk_super))
639 goto fail_sb_buffer;
640
641 nodesize = btrfs_super_nodesize(disk_super);
642 leafsize = btrfs_super_leafsize(disk_super);
643 sectorsize = btrfs_super_sectorsize(disk_super);
644 stripesize = btrfs_super_stripesize(disk_super);
645 tree_root->nodesize = nodesize;
646 tree_root->leafsize = leafsize;
647 tree_root->sectorsize = sectorsize;
648 tree_root->stripesize = stripesize;
649 sb_set_blocksize(sb, sectorsize);
650
651 i_size_write(fs_info->btree_inode,
652 btrfs_super_total_bytes(disk_super));
653
654 if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
655 sizeof(disk_super->magic))) {
656 printk("btrfs: valid FS not found on %s\n", sb->s_id);
657 goto fail_sb_buffer;
658 }
659
660 blocksize = btrfs_level_size(tree_root,
661 btrfs_super_root_level(disk_super));
662
663 tree_root->node = read_tree_block(tree_root,
664 btrfs_super_root(disk_super),
665 blocksize);
666 if (!tree_root->node)
667 goto fail_sb_buffer;
668
669 mutex_lock(&fs_info->fs_mutex);
670
671 ret = find_and_setup_root(tree_root, fs_info,
672 BTRFS_EXTENT_TREE_OBJECTID, extent_root);
673 if (ret) {
674 mutex_unlock(&fs_info->fs_mutex);
675 goto fail_tree_root;
676 }
677
678 btrfs_read_block_groups(extent_root);
679
680 fs_info->generation = btrfs_super_generation(disk_super) + 1;
681 mutex_unlock(&fs_info->fs_mutex);
682 return tree_root;
683
684 fail_tree_root:
685 free_extent_buffer(tree_root->node);
686 fail_sb_buffer:
687 free_extent_buffer(fs_info->sb_buffer);
688 fail_iput:
689 iput(fs_info->btree_inode);
690 fail:
691 kfree(extent_root);
692 kfree(tree_root);
693 kfree(fs_info);
694 return ERR_PTR(err);
695 }
696
697 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
698 *root)
699 {
700 int ret;
701 struct extent_buffer *super = root->fs_info->sb_buffer;
702 struct inode *btree_inode = root->fs_info->btree_inode;
703
704 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, super);
705 ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
706 super->start, super->len);
707 return ret;
708 }
709
710 int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
711 {
712 radix_tree_delete(&fs_info->fs_roots_radix,
713 (unsigned long)root->root_key.objectid);
714 btrfs_sysfs_del_root(root);
715 if (root->inode)
716 iput(root->inode);
717 if (root->node)
718 free_extent_buffer(root->node);
719 if (root->commit_root)
720 free_extent_buffer(root->commit_root);
721 if (root->name)
722 kfree(root->name);
723 kfree(root);
724 return 0;
725 }
726
727 static int del_fs_roots(struct btrfs_fs_info *fs_info)
728 {
729 int ret;
730 struct btrfs_root *gang[8];
731 int i;
732
733 while(1) {
734 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
735 (void **)gang, 0,
736 ARRAY_SIZE(gang));
737 if (!ret)
738 break;
739 for (i = 0; i < ret; i++)
740 btrfs_free_fs_root(fs_info, gang[i]);
741 }
742 return 0;
743 }
744
745 int close_ctree(struct btrfs_root *root)
746 {
747 int ret;
748 struct btrfs_trans_handle *trans;
749 struct btrfs_fs_info *fs_info = root->fs_info;
750
751 fs_info->closing = 1;
752 btrfs_transaction_flush_work(root);
753 mutex_lock(&fs_info->fs_mutex);
754 btrfs_defrag_dirty_roots(root->fs_info);
755 trans = btrfs_start_transaction(root, 1);
756 ret = btrfs_commit_transaction(trans, root);
757 /* run commit again to drop the original snapshot */
758 trans = btrfs_start_transaction(root, 1);
759 btrfs_commit_transaction(trans, root);
760 ret = btrfs_write_and_wait_transaction(NULL, root);
761 BUG_ON(ret);
762 write_ctree_super(NULL, root);
763 mutex_unlock(&fs_info->fs_mutex);
764
765 if (fs_info->extent_root->node)
766 free_extent_buffer(fs_info->extent_root->node);
767
768 if (fs_info->tree_root->node)
769 free_extent_buffer(fs_info->tree_root->node);
770
771 free_extent_buffer(fs_info->sb_buffer);
772
773 btrfs_free_block_groups(root->fs_info);
774 del_fs_roots(fs_info);
775
776 filemap_write_and_wait(fs_info->btree_inode->i_mapping);
777
778 extent_map_tree_empty_lru(&fs_info->free_space_cache);
779 extent_map_tree_empty_lru(&fs_info->block_group_cache);
780 extent_map_tree_empty_lru(&fs_info->pinned_extents);
781 extent_map_tree_empty_lru(&fs_info->pending_del);
782 extent_map_tree_empty_lru(&fs_info->extent_ins);
783 extent_map_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->extent_tree);
784
785 truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
786
787 iput(fs_info->btree_inode);
788 #if 0
789 while(!list_empty(&fs_info->hashers)) {
790 struct btrfs_hasher *hasher;
791 hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,
792 hashers);
793 list_del(&hasher->hashers);
794 crypto_free_hash(&fs_info->hash_tfm);
795 kfree(hasher);
796 }
797 #endif
798 kfree(fs_info->extent_root);
799 kfree(fs_info->tree_root);
800 return 0;
801 }
802
803 int btrfs_buffer_uptodate(struct extent_buffer *buf)
804 {
805 struct inode *btree_inode = buf->first_page->mapping->host;
806 return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
807 }
808
809 int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
810 {
811 struct inode *btree_inode = buf->first_page->mapping->host;
812 return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
813 buf);
814 }
815
816 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
817 {
818 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
819 u64 transid = btrfs_header_generation(buf);
820 struct inode *btree_inode = root->fs_info->btree_inode;
821
822 if (transid != root->fs_info->generation) {
823 printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
824 (unsigned long long)buf->start,
825 transid, root->fs_info->generation);
826 WARN_ON(1);
827 }
828 set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
829 }
830
831 void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
832 {
833 balance_dirty_pages_ratelimited_nr(
834 root->fs_info->btree_inode->i_mapping, 1);
835 }
836
837 void btrfs_set_buffer_defrag(struct extent_buffer *buf)
838 {
839 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
840 struct inode *btree_inode = root->fs_info->btree_inode;
841 set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
842 buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
843 }
844
845 void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
846 {
847 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
848 struct inode *btree_inode = root->fs_info->btree_inode;
849 set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
850 buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
851 GFP_NOFS);
852 }
853
854 int btrfs_buffer_defrag(struct extent_buffer *buf)
855 {
856 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
857 struct inode *btree_inode = root->fs_info->btree_inode;
858 return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
859 buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
860 }
861
862 int btrfs_buffer_defrag_done(struct extent_buffer *buf)
863 {
864 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
865 struct inode *btree_inode = root->fs_info->btree_inode;
866 return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
867 buf->start, buf->start + buf->len - 1,
868 EXTENT_DEFRAG_DONE, 0);
869 }
870
871 int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
872 {
873 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
874 struct inode *btree_inode = root->fs_info->btree_inode;
875 return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
876 buf->start, buf->start + buf->len - 1,
877 EXTENT_DEFRAG_DONE, GFP_NOFS);
878 }
879
880 int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
881 {
882 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
883 struct inode *btree_inode = root->fs_info->btree_inode;
884 return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
885 buf->start, buf->start + buf->len - 1,
886 EXTENT_DEFRAG, GFP_NOFS);
887 }
888
889 int btrfs_read_buffer(struct extent_buffer *buf)
890 {
891 struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
892 struct inode *btree_inode = root->fs_info->btree_inode;
893 return read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
894 buf, 0, 1);
895 }
896
897 static struct extent_map_ops btree_extent_map_ops = {
898 .writepage_io_hook = btree_writepage_io_hook,
899 };
Linux kernel - Deliverables
This page took 0.082518 seconds and 4 git commands to generate.