projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Btrfs: directory readahead
[linux-2.6-block.git] / fs / btrfs / disk-io.c
CommitLineData
e20d96d6
CM		 1#include <linux/module.h>
2#include <linux/fs.h>
d98237b3 3#include <linux/blkdev.h>
87cbda5c
CM		 4#include <linux/crypto.h>
5#include <linux/scatterlist.h>
22b0ebda 6#include <linux/swap.h>
0f7d52f4 7#include <linux/radix-tree.h>
090d1875 8#include <linux/file.h>
eb60ceac
CM		 9#include "ctree.h"
10#include "disk-io.h"
e089f05c 11#include "transaction.h"
0f7d52f4 12#include "btrfs_inode.h"
eb60ceac 13
7eccb903
CM		 14struct dev_lookup {
15 u64 block_start;
16 u64 num_blocks;
b4100d64 17 u64 device_id;
7eccb903
CM		 18 struct block_device *bdev;
19};
20
8352d8a4
CM		 21int btrfs_insert_dev_radix(struct btrfs_root *root,
22 struct block_device *bdev,
b4100d64 23 u64 device_id,
8352d8a4
CM		 24 u64 block_start,
25 u64 num_blocks)
26{
27 struct dev_lookup *lookup;
8352d8a4
CM		 28 int ret;
29
30 lookup = kmalloc(sizeof(*lookup), GFP_NOFS);
31 if (!lookup)
32 return -ENOMEM;
33 lookup->block_start = block_start;
34 lookup->num_blocks = num_blocks;
35 lookup->bdev = bdev;
b4100d64 36 lookup->device_id = device_id;
8352d8a4
CM		 37
38 ret = radix_tree_insert(&root->fs_info->dev_radix, block_start +
39 num_blocks - 1, lookup);
40 return ret;
41}
42
7eccb903
CM		 43u64 bh_blocknr(struct buffer_head *bh)
44{
45 int blkbits = bh->b_page->mapping->host->i_blkbits;
46 u64 blocknr = bh->b_page->index << (PAGE_CACHE_SHIFT - blkbits);
47 unsigned long offset;
48
49 if (PageHighMem(bh->b_page))
50 offset = (unsigned long)bh->b_data;
51 else
52 offset = bh->b_data - (char *)page_address(bh->b_page);
53 blocknr += offset >> (PAGE_CACHE_SHIFT - blkbits);
54 return blocknr;
55}
56
e20d96d6 57static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
eb60ceac 58{
e20d96d6 59 struct btrfs_node *node = btrfs_buffer_node(buf);
7eccb903 60 if (bh_blocknr(buf) != btrfs_header_blocknr(&node->header)) {
8352d8a4
CM		 61 printk(KERN_CRIT "bh_blocknr(buf) is %Lu, header is %Lu\n",
62 bh_blocknr(buf), btrfs_header_blocknr(&node->header));
9a8dd150 63 BUG();
d98237b3 64 }
9a8dd150 65 return 0;
eb60ceac
CM		 66}
67
d98237b3
CM		 68struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr)
69{
70 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
71 int blockbits = root->fs_info->sb->s_blocksize_bits;
72 unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
73 struct page *page;
74 struct buffer_head *bh;
75 struct buffer_head *head;
76 struct buffer_head *ret = NULL;
77
2c90e5d6 78
d98237b3
CM		 79 page = find_lock_page(mapping, index);
80 if (!page)
81 return NULL;
82
83 if (!page_has_buffers(page))
84 goto out_unlock;
85
86 head = page_buffers(page);
87 bh = head;
88 do {
7eccb903 89 if (buffer_mapped(bh) && bh_blocknr(bh) == blocknr) {
d98237b3
CM		 90 ret = bh;
91 get_bh(bh);
92 goto out_unlock;
93 }
94 bh = bh->b_this_page;
95 } while (bh != head);
96out_unlock:
97 unlock_page(page);
98 page_cache_release(page);
99 return ret;
100}
101
8352d8a4 102int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
7eccb903
CM		 103 u64 logical)
104{
105 struct dev_lookup *lookup[2];
7eccb903
CM		 106
107 int ret;
108
236454df
CM		 109 if (logical == 0) {
110 bh->b_bdev = NULL;
111 bh->b_blocknr = 0;
112 set_buffer_mapped(bh);
113 return 0;
114 }
7eccb903
CM		 115 root = root->fs_info->dev_root;
116 ret = radix_tree_gang_lookup(&root->fs_info->dev_radix,
117 (void **)lookup,
118 (unsigned long)logical,
119 ARRAY_SIZE(lookup));
120 if (ret == 0 || lookup[0]->block_start > logical ||
121 lookup[0]->block_start + lookup[0]->num_blocks <= logical) {
122 ret = -ENOENT;
123 goto out;
124 }
125 bh->b_bdev = lookup[0]->bdev;
126 bh->b_blocknr = logical - lookup[0]->block_start;
7eccb903
CM		 127 set_buffer_mapped(bh);
128 ret = 0;
129out:
130 return ret;
131}
132
d98237b3
CM		 133struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
134 u64 blocknr)
135{
136 struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
137 int blockbits = root->fs_info->sb->s_blocksize_bits;
138 unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
139 struct page *page;
140 struct buffer_head *bh;
141 struct buffer_head *head;
142 struct buffer_head *ret = NULL;
7eccb903 143 int err;
d98237b3 144 u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
22b0ebda 145
d98237b3
CM		 146 page = grab_cache_page(mapping, index);
147 if (!page)
148 return NULL;
149
d98237b3
CM		 150 if (!page_has_buffers(page))
151 create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0);
152 head = page_buffers(page);
153 bh = head;
154 do {
155 if (!buffer_mapped(bh)) {
8352d8a4 156 err = btrfs_map_bh_to_logical(root, bh, first_block);
7eccb903 157 BUG_ON(err);
d98237b3 158 }
7eccb903 159 if (bh_blocknr(bh) == blocknr) {
d98237b3
CM		 160 ret = bh;
161 get_bh(bh);
162 goto out_unlock;
163 }
164 bh = bh->b_this_page;
165 first_block++;
166 } while (bh != head);
167out_unlock:
168 unlock_page(page);
22b0ebda
CM		 169 if (ret)
170 touch_buffer(ret);
d98237b3
CM		 171 page_cache_release(page);
172 return ret;
173}
174
d98237b3
CM		 175static int btree_get_block(struct inode *inode, sector_t iblock,
176 struct buffer_head *bh, int create)
177{
7eccb903
CM		 178 int err;
179 struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root;
8352d8a4 180 err = btrfs_map_bh_to_logical(root, bh, iblock);
7eccb903 181 return err;
d98237b3
CM		 182}
183
f254e52c
CM		 184int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
185 char *result)
87cbda5c 186{
87cbda5c
CM		 187 struct scatterlist sg;
188 struct crypto_hash *tfm = root->fs_info->hash_tfm;
189 struct hash_desc desc;
190 int ret;
87cbda5c
CM		 191
192 desc.tfm = tfm;
193 desc.flags = 0;
f254e52c 194 sg_init_one(&sg, data, len);
87cbda5c 195 spin_lock(&root->fs_info->hash_lock);
22b0ebda 196 ret = crypto_hash_digest(&desc, &sg, 1, result);
87cbda5c
CM		 197 spin_unlock(&root->fs_info->hash_lock);
198 if (ret) {
199 printk("sha256 digest failed\n");
200 }
f254e52c
CM		 201 return ret;
202}
203static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh,
204 int verify)
205{
206 char result[BTRFS_CSUM_SIZE];
207 int ret;
208 struct btrfs_node *node;
209
210 ret = btrfs_csum_data(root, bh->b_data + BTRFS_CSUM_SIZE,
211 bh->b_size - BTRFS_CSUM_SIZE, result);
212 if (ret)
213 return ret;
87cbda5c 214 if (verify) {
f254e52c 215 if (memcmp(bh->b_data, result, BTRFS_CSUM_SIZE)) {
7eccb903
CM		 216 printk("checksum verify failed on %Lu\n",
217 bh_blocknr(bh));
f254e52c
CM		 218 return 1;
219 }
220 } else {
221 node = btrfs_buffer_node(bh);
22b0ebda 222 memcpy(node->header.csum, result, BTRFS_CSUM_SIZE);
f254e52c 223 }
87cbda5c
CM		 224 return 0;
225}
226
d98237b3 227static int btree_writepage(struct page *page, struct writeback_control *wbc)
ed2ff2cb 228{
87cbda5c 229 struct buffer_head *bh;
0f7d52f4 230 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
87cbda5c 231 struct buffer_head *head;
87cbda5c
CM		 232 if (!page_has_buffers(page)) {
233 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
234 (1 << BH_Dirty)|(1 << BH_Uptodate));
235 }
236 head = page_buffers(page);
237 bh = head;
238 do {
239 if (buffer_dirty(bh))
240 csum_tree_block(root, bh, 0);
241 bh = bh->b_this_page;
242 } while (bh != head);
d98237b3 243 return block_write_full_page(page, btree_get_block, wbc);
ed2ff2cb
CM		 244}
245
d98237b3 246static int btree_readpage(struct file * file, struct page * page)
eb60ceac 247{
d98237b3 248 return block_read_full_page(page, btree_get_block);
eb60ceac
CM		 249}
250
d98237b3
CM		 251static struct address_space_operations btree_aops = {
252 .readpage = btree_readpage,
253 .writepage = btree_writepage,
254 .sync_page = block_sync_page,
255};
256
090d1875
CM		 257int readahead_tree_block(struct btrfs_root *root, u64 blocknr)
258{
259 struct buffer_head *bh = NULL;
260
261 bh = btrfs_find_create_tree_block(root, blocknr);
262 if (!bh)
263 return 0;
264 if (buffer_uptodate(bh))
265 goto done;
266 if (test_set_buffer_locked(bh))
267 goto done;
268 if (!buffer_uptodate(bh)) {
269 get_bh(bh);
270 bh->b_end_io = end_buffer_read_sync;
271 submit_bh(READ, bh);
272 } else {
273 unlock_buffer(bh);
274 }
275done:
276 brelse(bh);
277 return 0;
278}
279
e20d96d6 280struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
eb60ceac 281{
d98237b3 282 struct buffer_head *bh = NULL;
eb60ceac 283
d98237b3
CM		 284 bh = btrfs_find_create_tree_block(root, blocknr);
285 if (!bh)
286 return bh;
9d64272c
CM		 287 if (buffer_uptodate(bh))
288 goto uptodate;
d98237b3
CM		 289 lock_buffer(bh);
290 if (!buffer_uptodate(bh)) {
291 get_bh(bh);
292 bh->b_end_io = end_buffer_read_sync;
293 submit_bh(READ, bh);
294 wait_on_buffer(bh);
295 if (!buffer_uptodate(bh))
296 goto fail;
297 } else {
298 unlock_buffer(bh);
299 }
9d64272c 300uptodate:
090d1875
CM		 301 if (!buffer_checked(bh)) {
302 csum_tree_block(root, bh, 1);
303 set_buffer_checked(bh);
304 }
d98237b3 305 if (check_tree_block(root, bh))
cfaa7295 306 BUG();
d98237b3
CM		 307 return bh;
308fail:
309 brelse(bh);
310 return NULL;
eb60ceac
CM		 311}
312
e089f05c 313int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
e20d96d6 314 struct buffer_head *buf)
ed2ff2cb 315{
d6025579 316 WARN_ON(atomic_read(&buf->b_count) == 0);
e20d96d6 317 mark_buffer_dirty(buf);
ed2ff2cb
CM		 318 return 0;
319}
320
e089f05c 321int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
e20d96d6 322 struct buffer_head *buf)
ed2ff2cb 323{
d6025579 324 WARN_ON(atomic_read(&buf->b_count) == 0);
e20d96d6 325 clear_buffer_dirty(buf);
ed2ff2cb
CM		 326 return 0;
327}
328
2c90e5d6 329static int __setup_root(int blocksize,
9f5fae2f
CM		 330 struct btrfs_root *root,
331 struct btrfs_fs_info *fs_info,
e20d96d6 332 u64 objectid)
d97e63b6 333{
cfaa7295 334 root->node = NULL;
0f7d52f4 335 root->inode = NULL;
a28ec197 336 root->commit_root = NULL;
2c90e5d6 337 root->blocksize = blocksize;
123abc88 338 root->ref_cows = 0;
9f5fae2f 339 root->fs_info = fs_info;
0f7d52f4
CM		 340 root->objectid = objectid;
341 root->last_trans = 0;
1b05da2e
CM		 342 root->highest_inode = 0;
343 root->last_inode_alloc = 0;
3768f368
CM		 344 memset(&root->root_key, 0, sizeof(root->root_key));
345 memset(&root->root_item, 0, sizeof(root->root_item));
4d775673 346 root->root_key.objectid = objectid;
3768f368
CM		 347 return 0;
348}
349
2c90e5d6 350static int find_and_setup_root(int blocksize,
9f5fae2f
CM		 351 struct btrfs_root *tree_root,
352 struct btrfs_fs_info *fs_info,
353 u64 objectid,
e20d96d6 354 struct btrfs_root *root)
3768f368
CM		 355{
356 int ret;
357
2c90e5d6 358 __setup_root(blocksize, root, fs_info, objectid);
3768f368
CM		 359 ret = btrfs_find_last_root(tree_root, objectid,
360 &root->root_item, &root->root_key);
361 BUG_ON(ret);
362
363 root->node = read_tree_block(root,
364 btrfs_root_blocknr(&root->root_item));
3768f368 365 BUG_ON(!root->node);
d97e63b6
CM		 366 return 0;
367}
368
0f7d52f4
CM		 369struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
370 struct btrfs_key *location)
371{
372 struct btrfs_root *root;
373 struct btrfs_root *tree_root = fs_info->tree_root;
374 struct btrfs_path *path;
375 struct btrfs_leaf *l;
1b05da2e 376 u64 highest_inode;
0f7d52f4
CM		 377 int ret = 0;
378
379printk("read_fs_root looking for %Lu %Lu %u\n", location->objectid, location->offset, location->flags);
2619ba1f
CM		 380 root = radix_tree_lookup(&fs_info->fs_roots_radix,
381 (unsigned long)location->objectid);
382 if (root) {
383printk("found %p in cache\n", root);
384 return root;
385 }
0f7d52f4
CM		 386 root = kmalloc(sizeof(*root), GFP_NOFS);
387 if (!root) {
388printk("failed1\n");
389 return ERR_PTR(-ENOMEM);
390 }
391 if (location->offset == (u64)-1) {
392 ret = find_and_setup_root(fs_info->sb->s_blocksize,
393 fs_info->tree_root, fs_info,
394 location->objectid, root);
395 if (ret) {
396printk("failed2\n");
397 kfree(root);
398 return ERR_PTR(ret);
399 }
400 goto insert;
401 }
402
403 __setup_root(fs_info->sb->s_blocksize, root, fs_info,
404 location->objectid);
405
406 path = btrfs_alloc_path();
407 BUG_ON(!path);
408 ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
409 if (ret != 0) {
410printk("internal search_slot gives us %d\n", ret);
411 if (ret > 0)
412 ret = -ENOENT;
413 goto out;
414 }
415 l = btrfs_buffer_leaf(path->nodes[0]);
416 memcpy(&root->root_item,
417 btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item),
418 sizeof(root->root_item));
419 memcpy(&root->root_key, location, sizeof(*location));
420 ret = 0;
421out:
422 btrfs_release_path(root, path);
423 btrfs_free_path(path);
424 if (ret) {
425 kfree(root);
426 return ERR_PTR(ret);
427 }
428 root->node = read_tree_block(root,
429 btrfs_root_blocknr(&root->root_item));
430 BUG_ON(!root->node);
431insert:
432printk("inserting %p\n", root);
433 root->ref_cows = 1;
2619ba1f
CM		 434 ret = radix_tree_insert(&fs_info->fs_roots_radix,
435 (unsigned long)root->root_key.objectid,
0f7d52f4
CM		 436 root);
437 if (ret) {
438printk("radix_tree_insert gives us %d\n", ret);
439 brelse(root->node);
440 kfree(root);
441 return ERR_PTR(ret);
442 }
1b05da2e
CM		 443 ret = btrfs_find_highest_inode(root, &highest_inode);
444 if (ret == 0) {
445 root->highest_inode = highest_inode;
446 root->last_inode_alloc = highest_inode;
447printk("highest inode is %Lu\n", highest_inode);
448 }
0f7d52f4
CM		 449printk("all worked\n");
450 return root;
451}
452
b4100d64
CM		 453static int btrfs_open_disk(struct btrfs_root *root, u64 device_id,
454 u64 block_start, u64 num_blocks,
455 char *filename, int name_len)
8352d8a4
CM		 456{
457 char *null_filename;
458 struct block_device *bdev;
459 int ret;
460
8352d8a4
CM		 461 null_filename = kmalloc(name_len + 1, GFP_NOFS);
462 if (!null_filename)
463 return -ENOMEM;
464 memcpy(null_filename, filename, name_len);
465 null_filename[name_len] = '\0';
466
467 bdev = open_bdev_excl(null_filename, O_RDWR, root->fs_info->sb);
468 if (IS_ERR(bdev)) {
469 ret = PTR_ERR(bdev);
470 goto out;
471 }
472 set_blocksize(bdev, root->fs_info->sb->s_blocksize);
b4100d64
CM		 473 ret = btrfs_insert_dev_radix(root, bdev, device_id,
474 block_start, num_blocks);
8352d8a4
CM		 475 BUG_ON(ret);
476 ret = 0;
477out:
478 kfree(null_filename);
479 return ret;
480}
481
482static int read_device_info(struct btrfs_root *root)
483{
484 struct btrfs_path *path;
485 int ret;
486 struct btrfs_key key;
487 struct btrfs_leaf *leaf;
488 struct btrfs_device_item *dev_item;
489 int nritems;
490 int slot;
491
492 root = root->fs_info->dev_root;
493
494 path = btrfs_alloc_path();
495 if (!path)
496 return -ENOMEM;
497 key.objectid = 0;
498 key.offset = 0;
499 key.flags = 0;
500 btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY);
501
502 mutex_lock(&root->fs_info->fs_mutex);
503 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
504 leaf = btrfs_buffer_leaf(path->nodes[0]);
505 nritems = btrfs_header_nritems(&leaf->header);
506 while(1) {
507 slot = path->slots[0];
508 if (slot >= nritems) {
509 ret = btrfs_next_leaf(root, path);
510 if (ret)
511 break;
512 leaf = btrfs_buffer_leaf(path->nodes[0]);
513 nritems = btrfs_header_nritems(&leaf->header);
514 slot = path->slots[0];
515 }
516 btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
517 if (btrfs_key_type(&key) != BTRFS_DEV_ITEM_KEY) {
518 path->slots[0]++;
519 continue;
520 }
521 dev_item = btrfs_item_ptr(leaf, slot, struct btrfs_device_item);
522printk("found key %Lu %Lu\n", key.objectid, key.offset);
b4100d64
CM		 523 if (btrfs_device_id(dev_item) !=
524 btrfs_super_device_id(root->fs_info->disk_super)) {
525 ret = btrfs_open_disk(root, btrfs_device_id(dev_item),
526 key.objectid, key.offset,
527 (char *)(dev_item + 1),
528 btrfs_device_pathlen(dev_item));
529 BUG_ON(ret);
530 }
8352d8a4
CM		 531 path->slots[0]++;
532 }
533 btrfs_free_path(path);
534 mutex_unlock(&root->fs_info->fs_mutex);
535 return 0;
536}
537
2c90e5d6 538struct btrfs_root *open_ctree(struct super_block *sb)
2e635a27 539{
e20d96d6
CM		 540 struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
541 GFP_NOFS);
0bd93ba0
CM		 542 struct btrfs_root *dev_root = kmalloc(sizeof(struct btrfs_root),
543 GFP_NOFS);
e20d96d6
CM		 544 struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
545 GFP_NOFS);
e20d96d6
CM		 546 struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
547 GFP_NOFS);
eb60ceac 548 int ret;
2c90e5d6 549 struct btrfs_super_block *disk_super;
7eccb903 550 struct dev_lookup *dev_lookup;
eb60ceac 551
8ef97622
CM		 552 init_bit_radix(&fs_info->pinned_radix);
553 init_bit_radix(&fs_info->pending_del_radix);
0f7d52f4 554 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
7eccb903 555 INIT_RADIX_TREE(&fs_info->dev_radix, GFP_NOFS);
9078a3e1 556 INIT_RADIX_TREE(&fs_info->block_group_radix, GFP_KERNEL);
8fd17795 557 INIT_LIST_HEAD(&fs_info->trans_list);
2c90e5d6 558 sb_set_blocksize(sb, 4096);
9f5fae2f 559 fs_info->running_transaction = NULL;
9f5fae2f
CM		 560 fs_info->tree_root = tree_root;
561 fs_info->extent_root = extent_root;
0bd93ba0 562 fs_info->dev_root = dev_root;
e20d96d6 563 fs_info->sb = sb;
d98237b3
CM		 564 fs_info->btree_inode = new_inode(sb);
565 fs_info->btree_inode->i_ino = 1;
2c90e5d6 566 fs_info->btree_inode->i_nlink = 1;
d98237b3
CM		 567 fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
568 fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
e66f709b 569 fs_info->do_barriers = 1;
f2458e1d
CM		 570 fs_info->extent_tree_insert_nr = 0;
571 fs_info->extent_tree_prealloc_nr = 0;
0f7d52f4
CM		 572 BTRFS_I(fs_info->btree_inode)->root = tree_root;
573 memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
574 sizeof(struct btrfs_key));
22b0ebda 575 insert_inode_hash(fs_info->btree_inode);
d98237b3 576 mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
87cbda5c 577 fs_info->hash_tfm = crypto_alloc_hash("sha256", 0, CRYPTO_ALG_ASYNC);
30ae8467 578 spin_lock_init(&fs_info->hash_lock);
30ae8467 579 if (!fs_info->hash_tfm || IS_ERR(fs_info->hash_tfm)) {
87cbda5c
CM		 580 printk("failed to allocate sha256 hash\n");
581 return NULL;
582 }
79154b1b 583 mutex_init(&fs_info->trans_mutex);
d561c025 584 mutex_init(&fs_info->fs_mutex);
cd1bc465 585 fs_info->block_group_cache = NULL;
3768f368 586
0bd93ba0
CM		 587 __setup_root(sb->s_blocksize, dev_root,
588 fs_info, BTRFS_DEV_TREE_OBJECTID);
589
2c90e5d6
CM		 590 __setup_root(sb->s_blocksize, tree_root,
591 fs_info, BTRFS_ROOT_TREE_OBJECTID);
7eccb903
CM		 592
593 dev_lookup = kmalloc(sizeof(*dev_lookup), GFP_NOFS);
594 dev_lookup->block_start = 0;
595 dev_lookup->num_blocks = (u32)-2;
596 dev_lookup->bdev = sb->s_bdev;
b4100d64 597 dev_lookup->device_id = 0;
7eccb903
CM		 598 ret = radix_tree_insert(&fs_info->dev_radix, (u32)-2, dev_lookup);
599 BUG_ON(ret);
2c90e5d6
CM		 600 fs_info->sb_buffer = read_tree_block(tree_root,
601 BTRFS_SUPER_INFO_OFFSET /
602 sb->s_blocksize);
d98237b3 603
0f7d52f4 604 if (!fs_info->sb_buffer)
d98237b3 605 return NULL;
d98237b3 606 disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
0f7d52f4 607 if (!btrfs_super_root(disk_super))
2c90e5d6 608 return NULL;
0f7d52f4 609
8352d8a4
CM		 610 i_size_write(fs_info->btree_inode,
611 btrfs_super_total_blocks(disk_super) <<
612 fs_info->btree_inode->i_blkbits);
613
7eccb903
CM		 614 radix_tree_delete(&fs_info->dev_radix, (u32)-2);
615 dev_lookup->block_start = btrfs_super_device_block_start(disk_super);
616 dev_lookup->num_blocks = btrfs_super_device_num_blocks(disk_super);
b4100d64
CM		 617 dev_lookup->device_id = btrfs_super_device_id(disk_super);
618
7eccb903
CM		 619 ret = radix_tree_insert(&fs_info->dev_radix,
620 dev_lookup->block_start +
8352d8a4 621 dev_lookup->num_blocks - 1, dev_lookup);
7eccb903
CM		 622 BUG_ON(ret);
623
d98237b3 624 fs_info->disk_super = disk_super;
8352d8a4 625
0bd93ba0
CM		 626 dev_root->node = read_tree_block(tree_root,
627 btrfs_super_device_root(disk_super));
8352d8a4
CM		 628
629 ret = read_device_info(dev_root);
630 BUG_ON(ret);
631
e20d96d6
CM		 632 tree_root->node = read_tree_block(tree_root,
633 btrfs_super_root(disk_super));
3768f368
CM		 634 BUG_ON(!tree_root->node);
635
2c90e5d6
CM		 636 mutex_lock(&fs_info->fs_mutex);
637 ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
e20d96d6 638 BTRFS_EXTENT_TREE_OBJECTID, extent_root);
3768f368
CM		 639 BUG_ON(ret);
640
9078a3e1
CM		 641 btrfs_read_block_groups(extent_root);
642
0f7d52f4 643 fs_info->generation = btrfs_super_generation(disk_super) + 1;
d6e4a428
CM		 644 memset(&fs_info->kobj, 0, sizeof(fs_info->kobj));
645 kobj_set_kset_s(fs_info, btrfs_subsys);
646 kobject_set_name(&fs_info->kobj, "%s", sb->s_id);
647 kobject_register(&fs_info->kobj);
5be6f7f1 648 mutex_unlock(&fs_info->fs_mutex);
0f7d52f4 649 return tree_root;
eb60ceac
CM		 650}
651
e089f05c 652int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
79154b1b 653 *root)
eb60ceac 654{
e66f709b 655 int ret;
d5719762 656 struct buffer_head *bh = root->fs_info->sb_buffer;
2c90e5d6 657
d5719762 658 btrfs_set_super_root(root->fs_info->disk_super,
7eccb903 659 bh_blocknr(root->fs_info->tree_root->node));
d5719762 660 lock_buffer(bh);
2c90e5d6 661 WARN_ON(atomic_read(&bh->b_count) < 1);
d5719762 662 clear_buffer_dirty(bh);
87cbda5c 663 csum_tree_block(root, bh, 0);
d5719762
CM		 664 bh->b_end_io = end_buffer_write_sync;
665 get_bh(bh);
e66f709b
CM		 666 if (root->fs_info->do_barriers)
667 ret = submit_bh(WRITE_BARRIER, bh);
668 else
669 ret = submit_bh(WRITE, bh);
670 if (ret == -EOPNOTSUPP) {
671 set_buffer_uptodate(bh);
672 root->fs_info->do_barriers = 0;
673 ret = submit_bh(WRITE, bh);
674 }
d5719762
CM		 675 wait_on_buffer(bh);
676 if (!buffer_uptodate(bh)) {
677 WARN_ON(1);
678 return -EIO;
cfaa7295
CM		 679 }
680 return 0;
681}
682
2619ba1f
CM		 683static int free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
684{
685 radix_tree_delete(&fs_info->fs_roots_radix,
686 (unsigned long)root->root_key.objectid);
687 if (root->inode)
688 iput(root->inode);
689 if (root->node)
690 brelse(root->node);
691 if (root->commit_root)
692 brelse(root->commit_root);
693 kfree(root);
694 return 0;
695}
696
0f7d52f4
CM		 697int del_fs_roots(struct btrfs_fs_info *fs_info)
698{
699 int ret;
700 struct btrfs_root *gang[8];
701 int i;
702
703 while(1) {
704 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
705 (void **)gang, 0,
706 ARRAY_SIZE(gang));
707 if (!ret)
708 break;
2619ba1f
CM		 709 for (i = 0; i < ret; i++)
710 free_fs_root(fs_info, gang[i]);
0f7d52f4
CM		 711 }
712 return 0;
713}
b4100d64 714
7eccb903
CM		 715static int free_dev_radix(struct btrfs_fs_info *fs_info)
716{
717 struct dev_lookup *lookup[8];
718 struct block_device *super_bdev = fs_info->sb->s_bdev;
719 int ret;
720 int i;
721 while(1) {
722 ret = radix_tree_gang_lookup(&fs_info->dev_radix,
723 (void **)lookup, 0,
724 ARRAY_SIZE(lookup));
725 if (!ret)
726 break;
727 for (i = 0; i < ret; i++) {
728 if (lookup[i]->bdev != super_bdev)
729 close_bdev_excl(lookup[i]->bdev);
730 radix_tree_delete(&fs_info->dev_radix,
731 lookup[i]->block_start +
8352d8a4 732 lookup[i]->num_blocks - 1);
7eccb903
CM		 733 kfree(lookup[i]);
734 }
735 }
736 return 0;
737}
0f7d52f4 738
e20d96d6 739int close_ctree(struct btrfs_root *root)
cfaa7295 740{
3768f368 741 int ret;
e089f05c 742 struct btrfs_trans_handle *trans;
0f7d52f4 743 struct btrfs_fs_info *fs_info = root->fs_info;
e089f05c 744
0f7d52f4 745 mutex_lock(&fs_info->fs_mutex);
79154b1b
CM		 746 trans = btrfs_start_transaction(root, 1);
747 btrfs_commit_transaction(trans, root);
748 /* run commit again to drop the original snapshot */
749 trans = btrfs_start_transaction(root, 1);
750 btrfs_commit_transaction(trans, root);
751 ret = btrfs_write_and_wait_transaction(NULL, root);
3768f368 752 BUG_ON(ret);
79154b1b 753 write_ctree_super(NULL, root);
0f7d52f4
CM		 754 mutex_unlock(&fs_info->fs_mutex);
755
756 if (fs_info->extent_root->node)
757 btrfs_block_release(fs_info->extent_root,
758 fs_info->extent_root->node);
0bd93ba0
CM		 759 if (fs_info->dev_root->node)
760 btrfs_block_release(fs_info->dev_root,
761 fs_info->dev_root->node);
0f7d52f4
CM		 762 if (fs_info->tree_root->node)
763 btrfs_block_release(fs_info->tree_root,
764 fs_info->tree_root->node);
765 btrfs_block_release(root, fs_info->sb_buffer);
766 crypto_free_hash(fs_info->hash_tfm);
767 truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
768 iput(fs_info->btree_inode);
7eccb903
CM		 769
770 free_dev_radix(fs_info);
9078a3e1 771 btrfs_free_block_groups(root->fs_info);
0f7d52f4
CM		 772 del_fs_roots(fs_info);
773 kfree(fs_info->extent_root);
0f7d52f4
CM		 774 kfree(fs_info->tree_root);
775 kobject_unregister(&fs_info->kobj);
eb60ceac
CM		 776 return 0;
777}
778
e20d96d6 779void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
eb60ceac 780{
7cfcc17e 781 brelse(buf);
eb60ceac
CM		 782}
783
Linux 6.x block layer and io_uring tree(s)