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, 1);
  55         if (ret)
  56                 goto error;
  57         ret = btrfs_insert_dir_item(trans, root, buf, 2, objectid,
  58                                     &inode_map, 1);
  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_root_dir(int fd) {
  68         struct btrfs_root *root;
  69         struct btrfs_super_block super;
  70         struct btrfs_trans_handle *trans;
  71         int ret;
  72         struct btrfs_key location;
  73
  74         root = open_ctree_fd(fd, &super);
  75
  76         if (!root) {
  77                 fprintf(stderr, "ctree init failed\n");
  78                 return -1;
  79         }
  80         trans = btrfs_start_transaction(root, 1);
  81         ret = __make_root_dir(trans, root->fs_info->tree_root,
  82                               BTRFS_ROOT_TREE_DIR_OBJECTID);
  83         if (ret)
  84                 goto err;
  85         ret = __make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
  86         if (ret)
  87                 goto err;
  88         memcpy(&location, &root->fs_info->fs_root->root_key, sizeof(location));
  89         location.offset = (u64)-1;
  90         ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
  91                         "default", strlen("default"),
  92                         btrfs_super_root_dir(root->fs_info->disk_super),
  93                         &location, 1);
  94         if (ret)
  95                 goto err;
  96         btrfs_commit_transaction(trans, root, root->fs_info->disk_super);
  97         ret = close_ctree(root, &super);
  98 err:
  99         return ret;
 100 }
 101
 102 int mkfs(int fd, char *pathname, u64 num_blocks, u32 blocksize)
 103 {
 104         struct btrfs_super_block super;
 105         struct btrfs_leaf *empty_leaf;
 106         struct btrfs_root_item root_item;
 107         struct btrfs_item item;
 108         struct btrfs_extent_item extent_item;
 109         struct btrfs_inode_item *inode_item;
 110         struct btrfs_device_item dev_item;
 111         char *block;
 112         int ret;
 113         u32 itemoff;
 114         u32 start_block = BTRFS_SUPER_INFO_OFFSET / blocksize;
 115         u16 item_size;
 116
 117         btrfs_set_super_generation(&super, 1);
 118         btrfs_set_super_blocknr(&super, start_block);
 119         btrfs_set_super_root(&super, start_block + 1);
 120         strcpy((char *)(&super.magic), BTRFS_MAGIC);
 121         btrfs_set_super_blocksize(&super, blocksize);
 122         btrfs_set_super_total_blocks(&super, num_blocks);
 123         btrfs_set_super_blocks_used(&super, start_block + 4);
 124         btrfs_set_super_device_block_start(&super, 0);
 125         btrfs_set_super_device_num_blocks(&super, num_blocks);
 126         btrfs_set_super_device_root(&super, start_block + 2);
 127         uuid_generate(super.fsid);
 128
 129         block = malloc(blocksize);
 130         memset(block, 0, blocksize);
 131         BUG_ON(sizeof(super) > blocksize);
 132         memcpy(block, &super, sizeof(super));
 133         ret = pwrite(fd, block, blocksize, BTRFS_SUPER_INFO_OFFSET);
 134         BUG_ON(ret != blocksize);
 135
 136         /* create the tree of root objects */
 137         empty_leaf = malloc(blocksize);
 138         memset(empty_leaf, 0, blocksize);
 139         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 1);
 140         btrfs_set_header_nritems(&empty_leaf->header, 2);
 141         btrfs_set_header_generation(&empty_leaf->header, 0);
 142         memcpy(empty_leaf->header.fsid, super.fsid,
 143                sizeof(empty_leaf->header.fsid));
 144
 145         /* create the items for the root tree */
 146         inode_item = &root_item.inode;
 147         memset(inode_item, 0, sizeof(*inode_item));
 148         btrfs_set_inode_generation(inode_item, 1);
 149         btrfs_set_inode_size(inode_item, 3);
 150         btrfs_set_inode_nlink(inode_item, 1);
 151         btrfs_set_inode_nblocks(inode_item, 1);
 152         btrfs_set_inode_mode(inode_item, S_IFDIR | 0755);
 153
 154         btrfs_set_root_dirid(&root_item, 0);
 155         btrfs_set_root_refs(&root_item, 1);
 156         btrfs_set_disk_key_offset(&item.key, 0);
 157         btrfs_set_disk_key_flags(&item.key, 0);
 158         btrfs_set_item_size(&item, sizeof(root_item));
 159         btrfs_set_disk_key_type(&item.key, BTRFS_ROOT_ITEM_KEY);
 160
 161         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - sizeof(root_item);
 162         btrfs_set_root_blocknr(&root_item, start_block + 3);
 163         btrfs_set_item_offset(&item, itemoff);
 164         btrfs_set_disk_key_objectid(&item.key, BTRFS_EXTENT_TREE_OBJECTID);
 165         memcpy(empty_leaf->items, &item, sizeof(item));
 166         memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
 167                 &root_item, sizeof(root_item));
 168
 169         btrfs_set_root_blocknr(&root_item, start_block + 4);
 170         itemoff = itemoff - sizeof(root_item);
 171         btrfs_set_item_offset(&item, itemoff);
 172         btrfs_set_disk_key_objectid(&item.key, BTRFS_FS_TREE_OBJECTID);
 173         memcpy(empty_leaf->items + 1, &item, sizeof(item));
 174         memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
 175                 &root_item, sizeof(root_item));
 176         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 1) * blocksize);
 177
 178         /* create the item for the dev tree */
 179         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 2);
 180         btrfs_set_header_nritems(&empty_leaf->header, 1);
 181         btrfs_set_disk_key_objectid(&item.key, 0);
 182         btrfs_set_disk_key_offset(&item.key, num_blocks);
 183         btrfs_set_disk_key_flags(&item.key, 0);
 184         btrfs_set_disk_key_type(&item.key, BTRFS_DEV_ITEM_KEY);
 185
 186         item_size = sizeof(struct btrfs_device_item) + strlen(pathname);
 187         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - item_size;
 188         btrfs_set_item_offset(&item, itemoff);
 189         btrfs_set_item_size(&item, item_size);
 190         btrfs_set_device_pathlen(&dev_item, strlen(pathname));
 191         memcpy(empty_leaf->items, &item, sizeof(item));
 192         memcpy(btrfs_leaf_data(empty_leaf) + itemoff, &dev_item,
 193                sizeof(dev_item));
 194         memcpy(btrfs_leaf_data(empty_leaf) + itemoff + sizeof(dev_item),
 195                pathname, strlen(pathname));
 196         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 2) * blocksize);
 197         if (ret != blocksize)
 198                 return -1;
 199
 200         /* create the items for the extent tree */
 201         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 3);
 202         btrfs_set_header_nritems(&empty_leaf->header, 5);
 203
 204         /* item1, reserve blocks 0-16 */
 205         btrfs_set_disk_key_objectid(&item.key, 0);
 206         btrfs_set_disk_key_offset(&item.key, start_block + 1);
 207         btrfs_set_disk_key_flags(&item.key, 0);
 208         btrfs_set_disk_key_type(&item.key, BTRFS_EXTENT_ITEM_KEY);
 209         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) -
 210                         sizeof(struct btrfs_extent_item);
 211         btrfs_set_item_offset(&item, itemoff);
 212         btrfs_set_item_size(&item, sizeof(struct btrfs_extent_item));
 213         btrfs_set_extent_refs(&extent_item, 1);
 214         memcpy(empty_leaf->items, &item, sizeof(item));
 215         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 216                 &extent_item, btrfs_item_size(&item));
 217
 218         /* item2, give block 17 to the root */
 219         btrfs_set_disk_key_objectid(&item.key, start_block + 1);
 220         btrfs_set_disk_key_offset(&item.key, 1);
 221         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 222         btrfs_set_item_offset(&item, itemoff);
 223         memcpy(empty_leaf->items + 1, &item, sizeof(item));
 224         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 225                 &extent_item, btrfs_item_size(&item));
 226
 227         /* item3, give block 18 to the dev root */
 228         btrfs_set_disk_key_objectid(&item.key, start_block + 2);
 229         btrfs_set_disk_key_offset(&item.key, 1);
 230         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 231         btrfs_set_item_offset(&item, itemoff);
 232         memcpy(empty_leaf->items + 2, &item, sizeof(item));
 233         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 234                 &extent_item, btrfs_item_size(&item));
 235
 236         /* item4, give block 19 to the extent root */
 237         btrfs_set_disk_key_objectid(&item.key, start_block + 3);
 238         btrfs_set_disk_key_offset(&item.key, 1);
 239         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 240         btrfs_set_item_offset(&item, itemoff);
 241         memcpy(empty_leaf->items + 3, &item, sizeof(item));
 242         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 243                 &extent_item, btrfs_item_size(&item));
 244
 245         /* item5, give block 20 to the FS root */
 246         btrfs_set_disk_key_objectid(&item.key, start_block + 4);
 247         btrfs_set_disk_key_offset(&item.key, 1);
 248         itemoff = itemoff - sizeof(struct btrfs_extent_item);
 249         btrfs_set_item_offset(&item, itemoff);
 250         memcpy(empty_leaf->items + 4, &item, sizeof(item));
 251         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
 252                 &extent_item, btrfs_item_size(&item));
 253         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 3) * blocksize);
 254         if (ret != blocksize)
 255                 return -1;
 256
 257         /* finally create the FS root */
 258         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 4);
 259         btrfs_set_header_nritems(&empty_leaf->header, 0);
 260         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 4) * blocksize);
 261         if (ret != blocksize)
 262                 return -1;
 263         return 0;
 264 }
 265
 266 u64 device_size(int fd, struct stat *st)
 267 {
 268         u64 size;
 269         if (S_ISREG(st->st_mode)) {
 270                 return st->st_size;
 271         }
 272         if (!S_ISBLK(st->st_mode)) {
 273                 return 0;
 274         }
 275         if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
 276                 return size;
 277         }
 278         return 0; }
 279
 280 int main(int ac, char **av)
 281 {
 282         char *file;
 283         u64 block_count = 0;
 284         int fd;
 285         struct stat st;
 286         int ret;
 287         int i;
 288         char *buf = malloc(4096);
 289         char *realpath_name;
 290
 291         radix_tree_init();
 292
 293         if (ac >= 2) {
 294                 file = av[1];
 295                 if (ac == 3) {
 296                         block_count = atoi(av[2]);
 297                         if (!block_count) {
 298                                 fprintf(stderr, "error finding block count\n");
 299                                 exit(1);
 300                         }
 301                 }
 302         } else {
 303                 fprintf(stderr, "usage: mkfs.btrfs file [block count]\n");
 304                 exit(1);
 305         }
 306         fd = open(file, O_RDWR);
 307         if (fd < 0) {
 308                 fprintf(stderr, "unable to open %s\n", file);
 309                 exit(1);
 310         }
 311         ret = fstat(fd, &st);
 312         if (ret < 0) {
 313                 fprintf(stderr, "unable to stat %s\n", file);
 314                 exit(1);
 315         }
 316         if (block_count == 0) {
 317                 block_count = device_size(fd, &st);
 318                 if (block_count == 0) {
 319                         fprintf(stderr, "unable to find %s size\n", file);
 320                         exit(1);
 321                 }
 322         }
 323         block_count /= 4096;
 324         if (block_count < 256) {
 325                 fprintf(stderr, "device %s is too small\n", file);
 326                 exit(1);
 327         }
 328         memset(buf, 0, 4096);
 329         for(i = 0; i < 64; i++) {
 330                 ret = write(fd, buf, 4096);
 331                 if (ret != 4096) {
 332                         fprintf(stderr, "unable to zero fill device\n");
 333                         exit(1);
 334                 }
 335         }
 336         realpath_name = realpath(file, NULL);
 337         ret = mkfs(fd, realpath_name, block_count, 4096);
 338         if (ret) {
 339                 fprintf(stderr, "error during mkfs %d\n", ret);
 340                 exit(1);
 341         }
 342         ret = make_root_dir(fd);
 343         if (ret) {
 344                 fprintf(stderr, "failed to setup the root directory\n");
 345                 exit(1);
 346         }
 347         printf("fs created on %s blocksize %d blocks %Lu\n",
 348                file, 4096, block_count);
 349         return 0;
 350 }
 351