struct block_device *bdev;
};
+int btrfs_insert_dev_radix(struct btrfs_root *root,
+ struct block_device *bdev,
+ u64 block_start,
+ u64 num_blocks)
+{
+ struct dev_lookup *lookup;
+ char b[BDEVNAME_SIZE];
+ int ret;
+
+ lookup = kmalloc(sizeof(*lookup), GFP_NOFS);
+ if (!lookup)
+ return -ENOMEM;
+ lookup->block_start = block_start;
+ lookup->num_blocks = num_blocks;
+ lookup->bdev = bdev;
+printk("inserting %s into dev radix %Lu %Lu\n", bdevname(bdev, b), block_start, num_blocks);
+
+ ret = radix_tree_insert(&root->fs_info->dev_radix, block_start +
+ num_blocks - 1, lookup);
+ return ret;
+}
+
u64 bh_blocknr(struct buffer_head *bh)
{
int blkbits = bh->b_page->mapping->host->i_blkbits;
{
struct btrfs_node *node = btrfs_buffer_node(buf);
if (bh_blocknr(buf) != btrfs_header_blocknr(&node->header)) {
+ printk(KERN_CRIT "bh_blocknr(buf) is %Lu, header is %Lu\n",
+ bh_blocknr(buf), btrfs_header_blocknr(&node->header));
BUG();
}
return 0;
return ret;
}
-static int map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
+int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
u64 logical)
{
struct dev_lookup *lookup[2];
- char b[BDEVNAME_SIZE];
int ret;
}
bh->b_bdev = lookup[0]->bdev;
bh->b_blocknr = logical - lookup[0]->block_start;
-printk("logical mapping %Lu to %lu bdev %s\n", logical, bh->b_blocknr, bdevname(bh->b_bdev, b));
set_buffer_mapped(bh);
ret = 0;
out:
bh = head;
do {
if (!buffer_mapped(bh)) {
- err = map_bh_to_logical(root, bh, first_block);
+ err = btrfs_map_bh_to_logical(root, bh, first_block);
BUG_ON(err);
}
if (bh_blocknr(bh) == blocknr) {
{
int err;
struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root;
- err = map_bh_to_logical(root, bh, iblock);
+ err = btrfs_map_bh_to_logical(root, bh, iblock);
return err;
}
return root;
}
+int btrfs_open_disk(struct btrfs_root *root, u64 block_start, u64 num_blocks,
+ char *filename, int name_len)
+{
+ char *null_filename;
+ struct block_device *bdev;
+ int ret;
+
+ if (block_start == 0) {
+printk("skipping disk with block_start == 0\n");
+return 0;
+ }
+ null_filename = kmalloc(name_len + 1, GFP_NOFS);
+ if (!null_filename)
+ return -ENOMEM;
+ memcpy(null_filename, filename, name_len);
+ null_filename[name_len] = '\0';
+
+ bdev = open_bdev_excl(null_filename, O_RDWR, root->fs_info->sb);
+ if (IS_ERR(bdev)) {
+ ret = PTR_ERR(bdev);
+ goto out;
+ }
+ set_blocksize(bdev, root->fs_info->sb->s_blocksize);
+ ret = btrfs_insert_dev_radix(root, bdev, block_start, num_blocks);
+ BUG_ON(ret);
+ ret = 0;
+out:
+ kfree(null_filename);
+ return ret;
+}
+
+static int read_device_info(struct btrfs_root *root)
+{
+ struct btrfs_path *path;
+ int ret;
+ struct btrfs_key key;
+ struct btrfs_leaf *leaf;
+ struct btrfs_device_item *dev_item;
+ int nritems;
+ int slot;
+
+ root = root->fs_info->dev_root;
+
+ path = btrfs_alloc_path();
+ if (!path)
+ return -ENOMEM;
+ key.objectid = 0;
+ key.offset = 0;
+ key.flags = 0;
+ btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY);
+
+ mutex_lock(&root->fs_info->fs_mutex);
+ ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+ leaf = btrfs_buffer_leaf(path->nodes[0]);
+ nritems = btrfs_header_nritems(&leaf->header);
+ while(1) {
+ slot = path->slots[0];
+ if (slot >= nritems) {
+ ret = btrfs_next_leaf(root, path);
+ if (ret)
+ break;
+ leaf = btrfs_buffer_leaf(path->nodes[0]);
+ nritems = btrfs_header_nritems(&leaf->header);
+ slot = path->slots[0];
+ }
+ btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
+ if (btrfs_key_type(&key) != BTRFS_DEV_ITEM_KEY) {
+ path->slots[0]++;
+ continue;
+ }
+ dev_item = btrfs_item_ptr(leaf, slot, struct btrfs_device_item);
+printk("found key %Lu %Lu\n", key.objectid, key.offset);
+ ret = btrfs_open_disk(root, key.objectid, key.offset,
+ (char *)(dev_item + 1),
+ btrfs_device_pathlen(dev_item));
+ BUG_ON(ret);
+ path->slots[0]++;
+ }
+ btrfs_free_path(path);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ return 0;
+}
+
struct btrfs_root *open_ctree(struct super_block *sb)
{
struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
if (!btrfs_super_root(disk_super))
return NULL;
+ i_size_write(fs_info->btree_inode,
+ btrfs_super_total_blocks(disk_super) <<
+ fs_info->btree_inode->i_blkbits);
+
radix_tree_delete(&fs_info->dev_radix, (u32)-2);
dev_lookup->block_start = btrfs_super_device_block_start(disk_super);
dev_lookup->num_blocks = btrfs_super_device_num_blocks(disk_super);
ret = radix_tree_insert(&fs_info->dev_radix,
dev_lookup->block_start +
- dev_lookup->num_blocks, dev_lookup);
+ dev_lookup->num_blocks - 1, dev_lookup);
BUG_ON(ret);
fs_info->disk_super = disk_super;
+
dev_root->node = read_tree_block(tree_root,
btrfs_super_device_root(disk_super));
+
+ ret = read_device_info(dev_root);
+ BUG_ON(ret);
+
tree_root->node = read_tree_block(tree_root,
btrfs_super_root(disk_super));
BUG_ON(!tree_root->node);
close_bdev_excl(lookup[i]->bdev);
radix_tree_delete(&fs_info->dev_radix,
lookup[i]->block_start +
- lookup[i]->num_blocks);
+ lookup[i]->num_blocks - 1);
kfree(lookup[i]);
}
}
struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
struct btrfs_key *location);
u64 bh_blocknr(struct buffer_head *bh);
+int btrfs_insert_dev_radix(struct btrfs_root *root,
+ struct block_device *bdev,
+ u64 block_start,
+ u64 num_blocks);
+int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
+ u64 logical);
#endif
#define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \
struct btrfs_ioctl_vol_args)
+#define BTRFS_IOC_ADD_DISK _IOW(BTRFS_IOCTL_MAGIC, 2, \
+ struct btrfs_ioctl_vol_args)
#endif
}
map_bh(result, inode->i_sb, blocknr);
+ btrfs_map_bh_to_logical(root, result, blocknr);
goto out;
}
extent_end = extent_start + btrfs_file_extent_num_blocks(item);
if (iblock >= extent_start && iblock < extent_end) {
err = 0;
- map_bh(result, inode->i_sb, blocknr + iblock - extent_start);
+ btrfs_map_bh_to_logical(root, result, blocknr + iblock -
+ extent_start);
goto out;
}
allocate:
set_buffer_new(result);
map_bh(result, inode->i_sb, blocknr);
+ btrfs_map_bh_to_logical(root, result, blocknr);
out:
btrfs_release_path(root, path);
btrfs_free_path(path);
return mpage_readpage(page, btrfs_get_block);
}
-static int btrfs_readpages(struct file *file, struct address_space *mapping,
- struct list_head *pages, unsigned nr_pages)
-{
- return mpage_readpages(mapping, pages, nr_pages, btrfs_get_block);
-}
-
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
{
return nobh_writepage(page, btrfs_get_block, wbc);
return 0;
}
+static int add_disk(struct btrfs_root *root, char *name, int namelen)
+{
+ struct block_device *bdev;
+ struct btrfs_path *path;
+ struct super_block *sb = root->fs_info->sb;
+ struct btrfs_root *dev_root = root->fs_info->dev_root;
+ struct btrfs_trans_handle *trans;
+ struct btrfs_device_item *dev_item;
+ struct btrfs_key key;
+ u16 item_size;
+ u64 num_blocks;
+ u64 new_blocks;
+ int ret;
+printk("adding disk %s\n", name);
+ path = btrfs_alloc_path();
+ if (!path)
+ return -ENOMEM;
+ num_blocks = btrfs_super_total_blocks(root->fs_info->disk_super);
+ bdev = open_bdev_excl(name, O_RDWR, sb);
+ if (IS_ERR(bdev)) {
+ ret = PTR_ERR(bdev);
+printk("open bdev excl failed ret %d\n", ret);
+ goto out_nolock;
+ }
+ set_blocksize(bdev, sb->s_blocksize);
+ new_blocks = bdev->bd_inode->i_size >> sb->s_blocksize_bits;
+ key.objectid = num_blocks;
+ key.offset = new_blocks;
+ key.flags = 0;
+ btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY);
+
+ mutex_lock(&dev_root->fs_info->fs_mutex);
+ trans = btrfs_start_transaction(dev_root, 1);
+ item_size = sizeof(*dev_item) + namelen;
+printk("insert empty on %Lu %Lu %u size %d\n", num_blocks, new_blocks, key.flags, item_size);
+ ret = btrfs_insert_empty_item(trans, dev_root, path, &key, item_size);
+ if (ret) {
+printk("insert failed %d\n", ret);
+ close_bdev_excl(bdev);
+ if (ret > 0)
+ ret = -EEXIST;
+ goto out;
+ }
+ dev_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
+ path->slots[0], struct btrfs_device_item);
+ btrfs_set_device_pathlen(dev_item, namelen);
+ memcpy(dev_item + 1, name, namelen);
+ mark_buffer_dirty(path->nodes[0]);
+
+ ret = btrfs_insert_dev_radix(root, bdev, num_blocks, new_blocks);
+
+ if (!ret) {
+ btrfs_set_super_total_blocks(root->fs_info->disk_super,
+ num_blocks + new_blocks);
+ i_size_write(root->fs_info->btree_inode,
+ (num_blocks + new_blocks) <<
+ root->fs_info->btree_inode->i_blkbits);
+ }
+
+out:
+ ret = btrfs_commit_transaction(trans, dev_root);
+ BUG_ON(ret);
+ mutex_unlock(&root->fs_info->fs_mutex);
+out_nolock:
+ btrfs_free_path(path);
+
+ return ret;
+}
+
static int btrfs_ioctl(struct inode *inode, struct file *filp, unsigned int
cmd, unsigned long arg)
{
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_ioctl_vol_args vol_args;
- int ret;
+ int ret = 0;
int namelen;
struct btrfs_path *path;
u64 root_dirid;
ret = create_snapshot(root, vol_args.name, namelen);
WARN_ON(ret);
break;
+ case BTRFS_IOC_ADD_DISK:
+ if (copy_from_user(&vol_args,
+ (struct btrfs_ioctl_vol_args __user *)arg,
+ sizeof(vol_args)))
+ return -EFAULT;
+ namelen = strlen(vol_args.name);
+ if (namelen > BTRFS_VOL_NAME_MAX)
+ return -EINVAL;
+ vol_args.name[namelen] = '\0';
+ ret = add_disk(root, vol_args.name, namelen);
+ break;
default:
return -ENOTTY;
}
- return 0;
+ return ret;
}
static struct kmem_cache *btrfs_inode_cachep;
static struct address_space_operations btrfs_aops = {
.readpage = btrfs_readpage,
- .readpages = btrfs_readpages,
.writepage = btrfs_writepage,
.sync_page = block_sync_page,
.prepare_write = btrfs_prepare_write,
struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_root *tree_root = fs_info->tree_root;
struct btrfs_root *extent_root = fs_info->extent_root;
+ struct btrfs_root *dev_root = fs_info->dev_root;
+ if (btrfs_super_device_root(fs_info->disk_super) !=
+ bh_blocknr(dev_root->node)) {
+ btrfs_set_super_device_root(fs_info->disk_super,
+ bh_blocknr(dev_root->node));
+ }
while(1) {
old_extent_block = btrfs_root_blocknr(&extent_root->root_item);
if (old_extent_block == bh_blocknr(extent_root->node))
projects / linux-2.6-block.git / commitdiff