Btrfs: add disk ioctl, mostly working

Signed-off-by: Chris Mason <chris.mason@oracle.com>

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index c872a7e67abd8e06adcd5fa8e10af1579c0914a0..3ba4df20c913fe77ac910cec7fb369ae29081370 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -16,6 +16,28 @@ struct dev_lookup {
        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;
@@ -34,6 +56,8 @@ static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
 {
        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;
@@ -76,11 +100,10 @@ out_unlock:
        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;
 
@@ -96,7 +119,6 @@ static int map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
        }
        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:
@@ -126,7 +148,7 @@ struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
        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) {
@@ -150,7 +172,7 @@ static int btree_get_block(struct inode *inode, sector_t iblock,
 {
        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;
 }
 
@@ -396,6 +418,89 @@ printk("all worked\n");
        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),
@@ -463,17 +568,26 @@ struct btrfs_root *open_ctree(struct super_block *sb)
        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);
@@ -562,7 +676,7 @@ static int free_dev_radix(struct btrfs_fs_info *fs_info)
                                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]);
                }
        }

diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index 46cc5dc9d572a302ba1e55b1fcc43b960f74d8c9..aa9f56c3841901c75f974db17ab1df9ff1242e2e 100644 (file)
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -42,4 +42,10 @@ int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
 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

diff --git a/fs/btrfs/ioctl.h b/fs/btrfs/ioctl.h
index 201fb32707237657b58700335ad7800afe66f49a..497fadd98c3ad178f7e9b8015f2f8ab973c12669 100644 (file)
--- a/fs/btrfs/ioctl.h
+++ b/fs/btrfs/ioctl.h
@@ -10,4 +10,6 @@ struct btrfs_ioctl_vol_args {
 
 #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

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 4ff0cc1efb130ac24f34c3b3a4e11931029cad80..c46d7eafcf6270d1eda4af056893d76378185efb 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1073,6 +1073,7 @@ static int btrfs_get_block_lock(struct inode *inode, sector_t iblock,
 
                }
                map_bh(result, inode->i_sb, blocknr);
+               btrfs_map_bh_to_logical(root, result, blocknr);
                goto out;
        }
 
@@ -1092,7 +1093,8 @@ static int btrfs_get_block_lock(struct inode *inode, sector_t iblock,
        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:
@@ -1112,6 +1114,7 @@ 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);
@@ -1153,12 +1156,6 @@ static int btrfs_readpage(struct file *file, struct page *page)
        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);
@@ -1831,12 +1828,81 @@ printk("adding snapshot name %.*s root %Lu %Lu %u\n", namelen, name, key.objecti
        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;
@@ -1869,10 +1935,21 @@ static int btrfs_ioctl(struct inode *inode, struct file *filp, unsigned int
                        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;
@@ -2004,7 +2081,6 @@ static struct file_operations btrfs_dir_file_operations = {
 
 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,

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 3a15943ea8ed227c458a9fbd4f30cb4c1e474e07..8740752f3845efea1029b9b9688047cf98182df2 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -116,7 +116,13 @@ int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
        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))