utils.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #define _XOPEN_SOURCE 600
  20 #define __USE_XOPEN2K
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <uuid/uuid.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include "kerncompat.h"
  29 #include "radix-tree.h"
  30 #include "ctree.h"
  31 #include "disk-io.h"
  32 #include "transaction.h"
  33 #include "crc32c.h"
  34 #include "utils.h"
  35 static u64 reference_root_table[6] = {
  36         [1] =   BTRFS_ROOT_TREE_OBJECTID,
  37         [2] =   BTRFS_EXTENT_TREE_OBJECTID,
  38         [3] =   BTRFS_CHUNK_TREE_OBJECTID,
  39         [4] =   BTRFS_DEV_TREE_OBJECTID,
  40         [5] =   BTRFS_FS_TREE_OBJECTID,
  41 };
  42
  43 int make_btrfs(int fd, char *device_name,
  44                u64 blocks[6], u64 num_bytes, u32 nodesize,
  45                u32 leafsize, u32 sectorsize, u32 stripesize)
  46 {
  47         struct btrfs_super_block super;
  48         struct extent_buffer *buf;
  49         struct btrfs_root_item root_item;
  50         struct btrfs_disk_key disk_key;
  51         struct btrfs_extent_ref *extent_ref;
  52         struct btrfs_extent_item *extent_item;
  53         struct btrfs_inode_item *inode_item;
  54         struct btrfs_chunk *chunk;
  55         struct btrfs_dev_item *dev_item;
  56         struct btrfs_dev_extent *dev_extent;
  57         u8 *ptr;
  58         int i;
  59         int ret;
  60         u32 itemoff;
  61         u32 nritems = 0;
  62         u64 hash;
  63         u64 first_free;
  64         u64 ref_gen;
  65         u64 ref_root;
  66         u32 array_size;
  67         u32 item_size;
  68
  69         first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
  70         first_free &= ~((u64)sectorsize - 1);
  71
  72         num_bytes = (num_bytes / sectorsize) * sectorsize;
  73         uuid_generate(super.fsid);
  74         btrfs_set_super_bytenr(&super, blocks[0]);
  75         strncpy((char *)&super.magic, BTRFS_MAGIC, sizeof(super.magic));
  76         btrfs_set_super_generation(&super, 1);
  77         btrfs_set_super_root(&super, blocks[1]);
  78         btrfs_set_super_chunk_root(&super, blocks[3]);
  79         btrfs_set_super_total_bytes(&super, num_bytes);
  80         btrfs_set_super_bytes_used(&super, first_free + 5 * leafsize);
  81         btrfs_set_super_root_dir(&super, 0);
  82         btrfs_set_super_sectorsize(&super, sectorsize);
  83         btrfs_set_super_leafsize(&super, leafsize);
  84         btrfs_set_super_nodesize(&super, nodesize);
  85         btrfs_set_super_stripesize(&super, stripesize);
  86         btrfs_set_super_root_level(&super, 0);
  87         btrfs_set_super_chunk_root_level(&super, 0);
  88         btrfs_set_super_sys_array_size(&super, 0);
  89
  90         buf = malloc(sizeof(*buf) + max(sectorsize, leafsize));
  91
  92         /* create the tree of root objects */
  93         memset(buf->data, 0, leafsize);
  94         btrfs_set_header_bytenr(buf, blocks[1]);
  95         btrfs_set_header_nritems(buf, 3);
  96         btrfs_set_header_generation(buf, 1);
  97         btrfs_set_header_owner(buf, BTRFS_ROOT_TREE_OBJECTID);
  98         write_extent_buffer(buf, super.fsid, (unsigned long)
  99                             btrfs_header_fsid(buf), BTRFS_FSID_SIZE);
 100
 101         /* create the items for the root tree */
 102         memset(&root_item, 0, sizeof(root_item));
 103         inode_item = &root_item.inode;
 104         btrfs_set_stack_inode_generation(inode_item, 1);
 105         btrfs_set_stack_inode_size(inode_item, 3);
 106         btrfs_set_stack_inode_nlink(inode_item, 1);
 107         btrfs_set_stack_inode_nblocks(inode_item, 1);
 108         btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
 109         btrfs_set_root_refs(&root_item, 1);
 110         btrfs_set_root_used(&root_item, leafsize);
 111
 112         memset(&disk_key, 0, sizeof(disk_key));
 113         btrfs_set_disk_key_type(&disk_key, BTRFS_ROOT_ITEM_KEY);
 114         btrfs_set_disk_key_offset(&disk_key, 0);
 115         nritems = 0;
 116
 117         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) - sizeof(root_item);
 118         btrfs_set_root_bytenr(&root_item, blocks[2]);
 119         btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID);
 120         btrfs_set_item_key(buf, &disk_key, nritems);
 121         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 122         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 123                             sizeof(root_item));
 124         write_extent_buffer(buf, &root_item, btrfs_item_ptr_offset(buf,
 125                             nritems), sizeof(root_item));
 126         nritems++;
 127
 128         itemoff = itemoff - sizeof(root_item);
 129         btrfs_set_root_bytenr(&root_item, blocks[4]);
 130         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_TREE_OBJECTID);
 131         btrfs_set_item_key(buf, &disk_key, nritems);
 132         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 133         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 134                             sizeof(root_item));
 135         write_extent_buffer(buf, &root_item,
 136                             btrfs_item_ptr_offset(buf, nritems),
 137                             sizeof(root_item));
 138         nritems++;
 139
 140         itemoff = itemoff - sizeof(root_item);
 141         btrfs_set_root_bytenr(&root_item, blocks[5]);
 142         btrfs_set_disk_key_objectid(&disk_key, BTRFS_FS_TREE_OBJECTID);
 143         btrfs_set_item_key(buf, &disk_key, nritems);
 144         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 145         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 146                             sizeof(root_item));
 147         write_extent_buffer(buf, &root_item,
 148                             btrfs_item_ptr_offset(buf, nritems),
 149                             sizeof(root_item));
 150         nritems++;
 151
 152
 153         ret = pwrite(fd, buf->data, leafsize, blocks[1]);
 154         BUG_ON(ret != leafsize);
 155
 156         /* create the items for the extent tree */
 157         nritems = 0;
 158         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) -
 159                   sizeof(struct btrfs_extent_item);
 160         btrfs_set_disk_key_objectid(&disk_key, 0);
 161         btrfs_set_disk_key_offset(&disk_key, first_free);
 162         btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_ITEM_KEY);
 163         btrfs_set_item_key(buf, &disk_key, nritems);
 164         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 165         btrfs_set_item_size(buf, btrfs_item_nr(buf,  nritems),
 166                             sizeof(struct btrfs_extent_item));
 167         extent_item = btrfs_item_ptr(buf, nritems, struct btrfs_extent_item);
 168         btrfs_set_extent_refs(buf, extent_item, 1);
 169         nritems++;
 170         for (i = 1; i < 6; i++) {
 171                 BUG_ON(blocks[i] < first_free);
 172                 BUG_ON(blocks[i] < blocks[i - 1]);
 173
 174                 /* create extent item */
 175                 itemoff = itemoff - sizeof(struct btrfs_extent_item);
 176                 btrfs_set_disk_key_objectid(&disk_key, blocks[i]);
 177                 btrfs_set_disk_key_offset(&disk_key, leafsize);
 178                 btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_ITEM_KEY);
 179                 btrfs_set_item_key(buf, &disk_key, nritems);
 180                 btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems),
 181                                       itemoff);
 182                 btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 183                                     sizeof(struct btrfs_extent_item));
 184                 extent_item = btrfs_item_ptr(buf, nritems,
 185                                              struct btrfs_extent_item);
 186                 btrfs_set_extent_refs(buf, extent_item, 1);
 187                 nritems++;
 188
 189                 /* create extent ref */
 190                 ref_root = reference_root_table[i];
 191                 if (ref_root == BTRFS_FS_TREE_OBJECTID)
 192                         ref_gen = 1;
 193                 else
 194                         ref_gen = 0;
 195
 196                 hash = btrfs_hash_extent_ref(ref_root, ref_gen, 0, 0);
 197                 itemoff = itemoff - sizeof(struct btrfs_extent_ref);
 198                 btrfs_set_disk_key_objectid(&disk_key, blocks[i]);
 199                 btrfs_set_disk_key_offset(&disk_key, hash);
 200                 btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_REF_KEY);
 201                 btrfs_set_item_key(buf, &disk_key, nritems);
 202                 btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems),
 203                                       itemoff);
 204                 btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 205                                     sizeof(struct btrfs_extent_ref));
 206                 extent_ref = btrfs_item_ptr(buf, nritems,
 207                                              struct btrfs_extent_ref);
 208                 btrfs_set_ref_root(buf, extent_ref, ref_root);
 209                 btrfs_set_ref_generation(buf, extent_ref, ref_gen);
 210                 btrfs_set_ref_objectid(buf, extent_ref, 0);
 211                 btrfs_set_ref_offset(buf, extent_ref, 0);
 212                 nritems++;
 213         }
 214         btrfs_set_header_bytenr(buf, blocks[2]);
 215         btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID);
 216         btrfs_set_header_nritems(buf, nritems);
 217         ret = pwrite(fd, buf->data, leafsize, blocks[2]);
 218         BUG_ON(ret != leafsize);
 219
 220         /* create the chunk tree */
 221         nritems = 0;
 222         item_size = btrfs_chunk_item_size(1);
 223         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) - item_size;
 224
 225         /* first we have chunk 0 */
 226         btrfs_set_disk_key_objectid(&disk_key, 0);
 227         btrfs_set_disk_key_offset(&disk_key, BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 228         btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY);
 229         btrfs_set_item_key(buf, &disk_key, nritems);
 230         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 231         btrfs_set_item_size(buf, btrfs_item_nr(buf,  nritems), item_size);
 232
 233         chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk);
 234         btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID);
 235         btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024);
 236         btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM);
 237         btrfs_set_chunk_io_align(buf, chunk, sectorsize);
 238         btrfs_set_chunk_io_width(buf, chunk, sectorsize);
 239         btrfs_set_chunk_sector_size(buf, chunk, sectorsize);
 240         btrfs_set_chunk_num_stripes(buf, chunk, 1);
 241         btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
 242         btrfs_set_stripe_offset_nr(buf, chunk, 0, 0);
 243
 244         /* copy the key for the chunk to the system array */
 245         ptr = super.sys_chunk_array;
 246         array_size = sizeof(disk_key);
 247
 248         memcpy(ptr, &disk_key, sizeof(disk_key));
 249         ptr += sizeof(disk_key);
 250
 251         /* copy the chunk to the system array */
 252         read_extent_buffer(buf, ptr, (unsigned long)chunk, item_size);
 253         array_size += item_size;
 254         ptr += item_size;
 255         btrfs_set_super_sys_array_size(&super, array_size);
 256
 257         /* then device 1 (there is no device 0) */
 258         nritems++;
 259         item_size = sizeof(*dev_item) + strlen(device_name);
 260         itemoff = itemoff - item_size;
 261         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
 262         btrfs_set_disk_key_offset(&disk_key, 1);
 263         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY);
 264         btrfs_set_item_key(buf, &disk_key, nritems);
 265         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 266         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems), item_size);
 267
 268         dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item);
 269         btrfs_set_device_id(buf, dev_item, 1);
 270         btrfs_set_device_total_bytes(buf, dev_item, num_bytes);
 271         btrfs_set_device_bytes_used(buf, dev_item,
 272                                     BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 273         btrfs_set_device_io_align(buf, dev_item, sectorsize);
 274         btrfs_set_device_io_width(buf, dev_item, sectorsize);
 275         btrfs_set_device_sector_size(buf, dev_item, sectorsize);
 276         btrfs_set_device_type(buf, dev_item, 0);
 277         nritems++;
 278
 279         uuid_generate(super.dev_item.uuid);
 280
 281         write_extent_buffer(buf, super.dev_item.uuid,
 282                             (unsigned long)btrfs_device_uuid(dev_item),
 283                             BTRFS_DEV_UUID_SIZE);
 284         read_extent_buffer(buf, &super.dev_item, (unsigned long)dev_item,
 285                            sizeof(*dev_item));
 286
 287         btrfs_set_header_bytenr(buf, blocks[3]);
 288         btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID);
 289         btrfs_set_header_nritems(buf, nritems);
 290         ret = pwrite(fd, buf->data, leafsize, blocks[3]);
 291
 292         /* create the device tree */
 293         nritems = 0;
 294         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) -
 295                 sizeof(struct btrfs_dev_extent);
 296
 297         btrfs_set_disk_key_objectid(&disk_key, 1);
 298         btrfs_set_disk_key_offset(&disk_key, 0);
 299         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY);
 300         btrfs_set_item_key(buf, &disk_key, nritems);
 301         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 302         btrfs_set_item_size(buf, btrfs_item_nr(buf,  nritems),
 303                             sizeof(struct btrfs_dev_extent));
 304         dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent);
 305         btrfs_set_dev_extent_owner(buf, dev_extent, 0);
 306         btrfs_set_dev_extent_length(buf, dev_extent,
 307                                     BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 308         nritems++;
 309
 310         btrfs_set_header_bytenr(buf, blocks[4]);
 311         btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID);
 312         btrfs_set_header_nritems(buf, nritems);
 313         ret = pwrite(fd, buf->data, leafsize, blocks[4]);
 314
 315         /* finally create the FS root */
 316         btrfs_set_header_bytenr(buf, blocks[5]);
 317         btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID);
 318         btrfs_set_header_nritems(buf, 0);
 319         ret = pwrite(fd, buf->data, leafsize, blocks[5]);
 320         BUG_ON(ret != leafsize);
 321
 322         /* and write out the super block */
 323         BUG_ON(sizeof(super) > sectorsize);
 324         memset(buf->data, 0, sectorsize);
 325         memcpy(buf->data, &super, sizeof(super));
 326         ret = pwrite(fd, buf->data, sectorsize, blocks[0]);
 327         BUG_ON(ret != sectorsize);
 328
 329
 330         free(buf);
 331         return 0;
 332 }
 333
 334 int btrfs_make_root_dir(struct btrfs_trans_handle *trans,
 335                         struct btrfs_root *root, u64 objectid)
 336 {
 337         int ret;
 338         struct btrfs_inode_item inode_item;
 339
 340         memset(&inode_item, 0, sizeof(inode_item));
 341         btrfs_set_stack_inode_generation(&inode_item, trans->transid);
 342         btrfs_set_stack_inode_size(&inode_item, 0);
 343         btrfs_set_stack_inode_nlink(&inode_item, 1);
 344         btrfs_set_stack_inode_nblocks(&inode_item, 1);
 345         btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0555);
 346
 347         if (root->fs_info->tree_root == root)
 348                 btrfs_set_super_root_dir(&root->fs_info->super_copy, objectid);
 349
 350         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
 351         if (ret)
 352                 goto error;
 353
 354         ret = btrfs_insert_inode_ref(trans, root, "..", 2, objectid, objectid);
 355         if (ret)
 356                 goto error;
 357
 358         btrfs_set_root_dirid(&root->root_item, objectid);
 359         ret = 0;
 360 error:
 361         return ret;
 362 }