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