mkfs.c

   1 #define _XOPEN_SOURCE 500
   2 #ifndef __CHECKER__
   3 #include <sys/ioctl.h>
   4 #include <sys/mount.h>
   5 #endif
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <fcntl.h>
  11 #include <unistd.h>
  12 #include <uuid/uuid.h>
  13 #include "kerncompat.h"
  14 #include "radix-tree.h"
  15 #include "ctree.h"
  16 #include "disk-io.h"
  17 #include "transaction.h"
  18
  19 #ifdef __CHECKER__
  20 #define BLKGETSIZE64 0
  21 static inline int ioctl(int fd, int define, u64 *size) { return 0; }
  22 #endif
  23
  24 static int __make_root_dir(struct btrfs_trans_handle *trans,
  25                            struct btrfs_root *root, u64 objectid)
  26 {
  27         int ret;
  28         char buf[8];
  29         struct btrfs_key inode_map;
  30         struct btrfs_inode_item inode_item;
  31
  32         buf[0] = '.';
  33         buf[1] = '.';
  34
  35         inode_map.objectid = objectid;
  36         inode_map.flags = 0;
  37         btrfs_set_key_type(&inode_map, BTRFS_INODE_ITEM_KEY);
  38         inode_map.offset = 0;
  39
  40         memset(&inode_item, 0, sizeof(inode_item));
  41         btrfs_set_inode_generation(&inode_item, root->fs_info->generation);
  42         btrfs_set_inode_size(&inode_item, 6);
  43         btrfs_set_inode_nlink(&inode_item, 1);
  44         btrfs_set_inode_nblocks(&inode_item, 1);
  45         btrfs_set_inode_mode(&inode_item, S_IFDIR | 0555);
  46
  47         if (root->fs_info->tree_root == root)
  48                 btrfs_set_super_root_dir(root->fs_info->disk_super, objectid);
  49
  50         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
  51         if (ret)
  52                 goto error;
  53         ret = btrfs_insert_dir_item(trans, root, buf, 1, objectid,
  54                                     &inode_map, BTRFS_FT_DIR);
  55         if (ret)
  56                 goto error;
  57         ret = btrfs_insert_dir_item(trans, root, buf, 2, objectid,
  58                                     &inode_map, BTRFS_FT_DIR);
  59         if (ret)
  60                 goto error;
  61         btrfs_set_root_dirid(&root->root_item, objectid);
  62         ret = 0;
  63 error:
  64         return ret;
  65 }
  66
  67 static int make_block_groups(struct btrfs_trans_handle *trans,
  68                              struct btrfs_root *root)
  69 {
  70         u64 group_size_blocks;
  71         u64 total_blocks;
  72         u64 cur_start;
  73         int ret;
  74         u64 nr = 0;
  75         struct btrfs_block_group_cache *cache;
  76
  77         root = root->fs_info->extent_root;
  78         /* first we bootstrap the things into cache */
  79         group_size_blocks = BTRFS_BLOCK_GROUP_SIZE / root->blocksize;
  80         cache = malloc(sizeof(*cache));
  81         cache->key.objectid = 0;
  82         cache->key.offset = group_size_blocks;
  83         cache->key.flags = 0;
  84         btrfs_set_key_type(&cache->key, BTRFS_BLOCK_GROUP_ITEM_KEY);
  85         memset(&cache->item, 0, sizeof(cache->item));
  86         btrfs_set_block_group_used(&cache->item,
  87                            btrfs_super_blocks_used(root->fs_info->disk_super));
  88         ret = radix_tree_insert(&root->fs_info->block_group_radix,
  89                                 group_size_blocks - 1, (void *)cache);
  90         BUG_ON(ret);
  91
  92         total_blocks = btrfs_super_total_blocks(root->fs_info->disk_super);
  93         cur_start = group_size_blocks;
  94         while(cur_start < total_blocks) {
  95                 cache = malloc(sizeof(*cache));
  96                 cache->key.objectid = cur_start;
  97                 cache->key.offset = group_size_blocks;
  98                 cache->key.flags = 0;
  99                 btrfs_set_key_type(&cache->key, BTRFS_BLOCK_GROUP_ITEM_KEY);
 100                 memset(&cache->item, 0, sizeof(cache->item));
 101                 if (nr % 3)
 102                         cache->item.flags |= BTRFS_BLOCK_GROUP_DATA;
 103
 104                 ret = radix_tree_insert(&root->fs_info->block_group_radix,
 105                                         cur_start + group_size_blocks - 1,
 106                                         (void *)cache);
 107                 BUG_ON(ret);
 108                 cur_start += group_size_blocks;
 109                 nr++;
 110         }
 111         /* then insert all the items */
 112         cur_start = 0;
 113         while(cur_start < total_blocks) {
 114                 cache = radix_tree_lookup(&root->fs_info->block_group_radix,
 115                                           cur_start + group_size_blocks - 1);
 116                 BUG_ON(!cache);
 117                 ret = btrfs_insert_block_group(trans, root, &cache->key,
 118                                                &cache->item);
 119                 BUG_ON(ret);
 120                 cur_start += group_size_blocks;
 121         }
 122         return 0;
 123 }
 124
 125 static int make_root_dir(int fd) {
 126         struct btrfs_root *root;
 127         struct btrfs_super_block super;
 128         struct btrfs_trans_handle *trans;
 129         int ret;
 130         struct btrfs_key location;
 131
 132         root = open_ctree_fd(fd, &super);
 133
 134         if (!root) {
 135                 fprintf(stderr, "ctree init failed\n");
 136                 return -1;
 137         }
 138         trans = btrfs_start_transaction(root, 1);
 139         ret = make_block_groups(trans, root);
 140         ret = __make_root_dir(trans, root->fs_info->tree_root,
 141                               BTRFS_ROOT_TREE_DIR_OBJECTID);
 142         if (ret)
 143                 goto err;
 144         ret = __make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
 145         if (ret)
 146                 goto err;
 147         memcpy(&location, &root->fs_info->fs_root->root_key, sizeof(location));
 148         location.offset = (u64)-1;
 149         ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
 150                         "default", strlen("default"),
 151                         btrfs_super_root_dir(root->fs_info->disk_super),
 152                         &location, BTRFS_FT_DIR);
 153         if (ret)
 154                 goto err;
 155         btrfs_commit_transaction(trans, root, root->fs_info->disk_super);
 156         ret = close_ctree(root, &super);
 157 err:
 158         return ret;
 159 }
 160
 161 int mkfs(int fd, char *pathname, u64 num_blocks, u32 blocksize)
 162 {
 163         struct btrfs_super_block super;
 164         struct btrfs_leaf *empty_leaf;
 165         struct btrfs_root_item root_item;
 166         struct btrfs_item item;
 167         struct btrfs_extent_item extent_item;
 168         struct btrfs_inode_item *inode_item;
 169         struct btrfs_device_item dev_item;
 170         char *block;
 171         int ret;
 172         u32 itemoff;
 173         u32 start_block = BTRFS_SUPER_INFO_OFFSET / blocksize;
 174         u16 item_size;
 175
 176         btrfs_set_super_generation(&super, 1);
 177         btrfs_set_super_blocknr(&super, start_block);
 178         btrfs_set_super_root(&super, start_block + 1);
 179         strcpy((char *)(&super.magic), BTRFS_MAGIC);
 180         btrfs_set_super_blocksize(&super, blocksize);
 181         btrfs_set_super_total_blocks(&super, num_blocks);
 182         btrfs_set_super_blocks_used(&super, start_block + 5);
 183         btrfs_set_super_device_block_start(&super, 0);
 184         btrfs_set_super_device_num_blocks(&super, num_blocks);
 185         btrfs_set_super_device_root(&super, start_block + 2);
 186         btrfs_set_super_device_id(&super, 1);
 187         btrfs_set_super_last_device_id(&super, 1);
 188         uuid_generate(super.fsid);
 189
 190         block = malloc(blocksize);
 191         memset(block, 0, blocksize);
 192         BUG_ON(sizeof(super) > blocksize);
 193         memcpy(block, &super, sizeof(super));
 194         ret = pwrite(fd, block, blocksize, BTRFS_SUPER_INFO_OFFSET);
 195         BUG_ON(ret != blocksize);
 196
 197         /* create the tree of root objects */
 198         empty_leaf = malloc(blocksize);
 199         memset(empty_leaf, 0, blocksize);
 200         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 1);
 201         btrfs_set_header_nritems(&empty_leaf->header, 2);
 202         btrfs_set_header_generation(&empty_leaf->header, 0);
 203         btrfs_set_header_owner(&empty_leaf->header, BTRFS_ROOT_TREE_OBJECTID);
 204         memcpy(empty_leaf->header.fsid, super.fsid,
 205                sizeof(empty_leaf->header.fsid));
 206
 207         /* create the items for the root tree */
 208         inode_item = &root_item.inode;
 209         memset(inode_item, 0, sizeof(*inode_item));
 210         btrfs_set_inode_generation(inode_item, 1);
 211         btrfs_set_inode_size(inode_item, 3);
 212         btrfs_set_inode_nlink(inode_item, 1);
 213         btrfs_set_inode_nblocks(inode_item, 1);
 214         btrfs_set_inode_mode(inode_item, S_IFDIR | 0755);
 215
 216         btrfs_set_root_dirid(&root_item, 0);
 217         btrfs_set_root_refs(&root_item, 1);
 218         btrfs_set_disk_key_offset(&item.key, 0);
 219         btrfs_set_disk_key_flags(&item.key, 0);
 220         btrfs_set_item_size(&item, sizeof(root_item));
 221         btrfs_set_disk_key_type(&item.key, BTRFS_ROOT_ITEM_KEY);
 222
 223         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - sizeof(root_item);
 224         btrfs_set_root_blocknr(&root_item, start_block + 3);
 225         btrfs_set_item_offset(&item, itemoff);
 226         btrfs_set_disk_key_objectid(&item.key, BTRFS_EXTENT_TREE_OBJECTID);
 227         memcpy(empty_leaf->items, &item, sizeof(item));
 228         memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
 229                 &root_item, sizeof(root_item));
 230
 231         btrfs_set_root_blocknr(&root_item, start_block + 4);
 232         itemoff = itemoff - sizeof(root_item);
 233         btrfs_set_item_offset(&item, itemoff);
 234         btrfs_set_disk_key_objectid(&item.key, BTRFS_FS_TREE_OBJECTID);
 235         memcpy(empty_leaf->items + 1, &item, sizeof(item));
 236         memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
 237                 &root_item, sizeof(root_item));
 238         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 1) * blocksize);
 239
 240         /* create the item for the dev tree */
 241         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 2);
 242         btrfs_set_header_nritems(&empty_leaf->header, 1);
 243         btrfs_set_disk_key_objectid(&item.key, 0);
 244         btrfs_set_disk_key_offset(&item.key, num_blocks);
 245         btrfs_set_disk_key_flags(&item.key, 0);
 246         btrfs_set_disk_key_type(&item.key, BTRFS_DEV_ITEM_KEY);
 247
 248         item_size = sizeof(struct btrfs_device_item) + strlen(pathname);
 249         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - item_size;
 250         btrfs_set_item_offset(&item, itemoff);
 251         btrfs_set_item_size(&item, item_size);
 252         btrfs_set_device_pathlen(&dev_item, strlen(pathname));
 253         btrfs_set_device_id(&dev_item, 1);
 254         memcpy(empty_leaf->items, &item, sizeof(item));
 255         memcpy(btrfs_leaf_data(empty_leaf) + itemoff, &dev_item,
 256                sizeof(dev_item));
 257         memcpy(btrfs_leaf_data(empty_leaf) + itemoff + sizeof(dev_item),
 258                pathname, strlen(pathname));
 259         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 2) * blocksize);
 260         if (ret != blocksize)
 261                 return -1;
 262
 263         /* create the items for the extent tree */
 264         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 3);
 265         btrfs_set_header_nritems(&empty_leaf->header, 5);
 266
 267         /* item1, reserve blocks 0-16 */
 268         btrfs_set_disk_key_objectid(&item.key, 0);
 269         btrfs_set_disk_key_offset(&item.key, start_block + 1);
 270         btrfs_set_disk_key_flags(&item.key, 0);
 271         btrfs_set_disk_key_type(&item.key, BTRFS_EXTENT_ITEM_KEY);
 272         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) -
 273                         sizeof(struct btrfs_extent_item);
 274         btrfs_set_item_offset(&item, itemoff);
 275         btrfs_set_item_size(&item, sizeof(struct btrfs_extent_item));
 276         btrfs_set_extent_refs(&extent_item, 1);
 277         btrfs_set_extent_owner(&extent_item, BTRFS_ROOT_TREE_OBJECTID);
 278         memcpy(empty_leaf->items, &item, sizeof(item));
 279         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 280                 &extent_item, btrfs_item_size(&item));
 281
 282         /* item2, give block 17 to the root */
 283         btrfs_set_disk_key_objectid(&item.key, start_block + 1);
 284         btrfs_set_disk_key_offset(&item.key, 1);
 285         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 286         btrfs_set_item_offset(&item, itemoff);
 287         memcpy(empty_leaf->items + 1, &item, sizeof(item));
 288         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 289                 &extent_item, btrfs_item_size(&item));
 290
 291         /* item3, give block 18 to the dev root */
 292         btrfs_set_disk_key_objectid(&item.key, start_block + 2);
 293         btrfs_set_disk_key_offset(&item.key, 1);
 294         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 295         btrfs_set_item_offset(&item, itemoff);
 296         memcpy(empty_leaf->items + 2, &item, sizeof(item));
 297         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 298                 &extent_item, btrfs_item_size(&item));
 299
 300         /* item4, give block 19 to the extent root */
 301         btrfs_set_disk_key_objectid(&item.key, start_block + 3);
 302         btrfs_set_disk_key_offset(&item.key, 1);
 303         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 304         btrfs_set_item_offset(&item, itemoff);
 305         memcpy(empty_leaf->items + 3, &item, sizeof(item));
 306         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 307                 &extent_item, btrfs_item_size(&item));
 308
 309         /* item5, give block 20 to the FS root */
 310         btrfs_set_disk_key_objectid(&item.key, start_block + 4);
 311         btrfs_set_disk_key_offset(&item.key, 1);
 312         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 313         btrfs_set_item_offset(&item, itemoff);
 314         memcpy(empty_leaf->items + 4, &item, sizeof(item));
 315         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 316                 &extent_item, btrfs_item_size(&item));
 317         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 3) * blocksize);
 318         if (ret != blocksize)
 319                 return -1;
 320
 321         /* finally create the FS root */
 322         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 4);
 323         btrfs_set_header_nritems(&empty_leaf->header, 0);
 324         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 4) * blocksize);
 325         if (ret != blocksize)
 326                 return -1;
 327         return 0;
 328 }
 329
 330 u64 device_size(int fd, struct stat *st)
 331 {
 332         u64 size;
 333         if (S_ISREG(st->st_mode)) {
 334                 return st->st_size;
 335         }
 336         if (!S_ISBLK(st->st_mode)) {
 337                 return 0;
 338         }
 339         if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
 340                 return size;
 341         }
 342         return 0; }
 343
 344 int main(int ac, char **av)
 345 {
 346         char *file;
 347         u64 block_count = 0;
 348         int fd;
 349         struct stat st;
 350         int ret;
 351         int i;
 352         char *buf = malloc(4096);
 353         char *realpath_name;
 354
 355         radix_tree_init();
 356
 357         if (ac >= 2) {
 358                 file = av[1];
 359                 if (ac == 3) {
 360                         block_count = atoi(av[2]);
 361                         if (!block_count) {
 362                                 fprintf(stderr, "error finding block count\n");
 363                                 exit(1);
 364                         }
 365                 }
 366         } else {
 367                 fprintf(stderr, "usage: mkfs.btrfs file [block count]\n");
 368                 exit(1);
 369         }
 370         fd = open(file, O_RDWR);
 371         if (fd < 0) {
 372                 fprintf(stderr, "unable to open %s\n", file);
 373                 exit(1);
 374         }
 375         ret = fstat(fd, &st);
 376         if (ret < 0) {
 377                 fprintf(stderr, "unable to stat %s\n", file);
 378                 exit(1);
 379         }
 380         if (block_count == 0) {
 381                 block_count = device_size(fd, &st);
 382                 if (block_count == 0) {
 383                         fprintf(stderr, "unable to find %s size\n", file);
 384                         exit(1);
 385                 }
 386                 block_count /= 4096;
 387         }
 388         if (block_count < 256) {
 389                 fprintf(stderr, "device %s is too small\n", file);
 390                 exit(1);
 391         }
 392         memset(buf, 0, 4096);
 393         for(i = 0; i < 64; i++) {
 394                 ret = write(fd, buf, 4096);
 395                 if (ret != 4096) {
 396                         fprintf(stderr, "unable to zero fill device\n");
 397                         exit(1);
 398                 }
 399         }
 400         realpath_name = realpath(file, NULL);
 401         ret = mkfs(fd, realpath_name, block_count, 4096);
 402         if (ret) {
 403                 fprintf(stderr, "error during mkfs %d\n", ret);
 404                 exit(1);
 405         }
 406         ret = make_root_dir(fd);
 407         if (ret) {
 408                 fprintf(stderr, "failed to setup the root directory\n");
 409                 exit(1);
 410         }
 411         printf("fs created on %s blocksize %d blocks %Lu\n",
 412                file, 4096, block_count);
 413         return 0;
 414 }
 415