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