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 #ifndef __CHECKER__
  24 #include <sys/ioctl.h>
  25 #include <sys/mount.h>
  26 #endif
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <uuid/uuid.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include "kerncompat.h"
  33 #include "radix-tree.h"
  34 #include "ctree.h"
  35 #include "disk-io.h"
  36 #include "transaction.h"
  37 #include "crc32c.h"
  38 #include "utils.h"
  39 #include "volumes.h"
  40
  41 #ifdef __CHECKER__
  42 #define BLKGETSIZE64 0
  43 static inline int ioctl(int fd, int define, u64 *size) { return 0; }
  44 #endif
  45
  46 static u64 reference_root_table[6] = {
  47         [1] =   BTRFS_ROOT_TREE_OBJECTID,
  48         [2] =   BTRFS_EXTENT_TREE_OBJECTID,
  49         [3] =   BTRFS_CHUNK_TREE_OBJECTID,
  50         [4] =   BTRFS_DEV_TREE_OBJECTID,
  51         [5] =   BTRFS_FS_TREE_OBJECTID,
  52 };
  53
  54 int make_btrfs(int fd, char *device_name,
  55                u64 blocks[6], u64 num_bytes, u32 nodesize,
  56                u32 leafsize, u32 sectorsize, u32 stripesize)
  57 {
  58         struct btrfs_super_block super;
  59         struct extent_buffer *buf;
  60         struct btrfs_root_item root_item;
  61         struct btrfs_disk_key disk_key;
  62         struct btrfs_extent_ref *extent_ref;
  63         struct btrfs_extent_item *extent_item;
  64         struct btrfs_inode_item *inode_item;
  65         struct btrfs_chunk *chunk;
  66         struct btrfs_dev_item *dev_item;
  67         struct btrfs_dev_extent *dev_extent;
  68         u8 *ptr;
  69         int i;
  70         int ret;
  71         u32 itemoff;
  72         u32 nritems = 0;
  73         u64 hash;
  74         u64 first_free;
  75         u64 ref_gen;
  76         u64 ref_root;
  77         u32 array_size;
  78         u32 item_size;
  79
  80         first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
  81         first_free &= ~((u64)sectorsize - 1);
  82
  83         num_bytes = (num_bytes / sectorsize) * sectorsize;
  84         uuid_generate(super.fsid);
  85         btrfs_set_super_bytenr(&super, blocks[0]);
  86         btrfs_set_super_num_devices(&super, 1);
  87         strncpy((char *)&super.magic, BTRFS_MAGIC, sizeof(super.magic));
  88         btrfs_set_super_generation(&super, 1);
  89         btrfs_set_super_root(&super, blocks[1]);
  90         btrfs_set_super_chunk_root(&super, blocks[3]);
  91         btrfs_set_super_total_bytes(&super, num_bytes);
  92         btrfs_set_super_bytes_used(&super, first_free + 5 * leafsize);
  93         btrfs_set_super_root_dir(&super, 0);
  94         btrfs_set_super_sectorsize(&super, sectorsize);
  95         btrfs_set_super_leafsize(&super, leafsize);
  96         btrfs_set_super_nodesize(&super, nodesize);
  97         btrfs_set_super_stripesize(&super, stripesize);
  98         btrfs_set_super_root_level(&super, 0);
  99         btrfs_set_super_chunk_root_level(&super, 0);
 100         btrfs_set_super_sys_array_size(&super, 0);
 101
 102         buf = malloc(sizeof(*buf) + max(sectorsize, leafsize));
 103
 104         /* create the tree of root objects */
 105         memset(buf->data, 0, leafsize);
 106         btrfs_set_header_bytenr(buf, blocks[1]);
 107         btrfs_set_header_nritems(buf, 3);
 108         btrfs_set_header_generation(buf, 1);
 109         btrfs_set_header_owner(buf, BTRFS_ROOT_TREE_OBJECTID);
 110         write_extent_buffer(buf, super.fsid, (unsigned long)
 111                             btrfs_header_fsid(buf), BTRFS_FSID_SIZE);
 112
 113         /* create the items for the root tree */
 114         memset(&root_item, 0, sizeof(root_item));
 115         inode_item = &root_item.inode;
 116         btrfs_set_stack_inode_generation(inode_item, 1);
 117         btrfs_set_stack_inode_size(inode_item, 3);
 118         btrfs_set_stack_inode_nlink(inode_item, 1);
 119         btrfs_set_stack_inode_nblocks(inode_item, 1);
 120         btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
 121         btrfs_set_root_refs(&root_item, 1);
 122         btrfs_set_root_used(&root_item, leafsize);
 123
 124         memset(&disk_key, 0, sizeof(disk_key));
 125         btrfs_set_disk_key_type(&disk_key, BTRFS_ROOT_ITEM_KEY);
 126         btrfs_set_disk_key_offset(&disk_key, 0);
 127         nritems = 0;
 128
 129         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) - sizeof(root_item);
 130         btrfs_set_root_bytenr(&root_item, blocks[2]);
 131         btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID);
 132         btrfs_set_item_key(buf, &disk_key, nritems);
 133         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 134         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 135                             sizeof(root_item));
 136         write_extent_buffer(buf, &root_item, btrfs_item_ptr_offset(buf,
 137                             nritems), sizeof(root_item));
 138         nritems++;
 139
 140         itemoff = itemoff - sizeof(root_item);
 141         btrfs_set_root_bytenr(&root_item, blocks[4]);
 142         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_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         itemoff = itemoff - sizeof(root_item);
 153         btrfs_set_root_bytenr(&root_item, blocks[5]);
 154         btrfs_set_disk_key_objectid(&disk_key, BTRFS_FS_TREE_OBJECTID);
 155         btrfs_set_item_key(buf, &disk_key, nritems);
 156         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 157         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 158                             sizeof(root_item));
 159         write_extent_buffer(buf, &root_item,
 160                             btrfs_item_ptr_offset(buf, nritems),
 161                             sizeof(root_item));
 162         nritems++;
 163
 164
 165         ret = pwrite(fd, buf->data, leafsize, blocks[1]);
 166         BUG_ON(ret != leafsize);
 167
 168         /* create the items for the extent tree */
 169         nritems = 0;
 170         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) -
 171                   sizeof(struct btrfs_extent_item);
 172         btrfs_set_disk_key_objectid(&disk_key, 0);
 173         btrfs_set_disk_key_offset(&disk_key, first_free);
 174         btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_ITEM_KEY);
 175         btrfs_set_item_key(buf, &disk_key, nritems);
 176         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 177         btrfs_set_item_size(buf, btrfs_item_nr(buf,  nritems),
 178                             sizeof(struct btrfs_extent_item));
 179         extent_item = btrfs_item_ptr(buf, nritems, struct btrfs_extent_item);
 180         btrfs_set_extent_refs(buf, extent_item, 1);
 181         nritems++;
 182         for (i = 1; i < 6; i++) {
 183                 BUG_ON(blocks[i] < first_free);
 184                 BUG_ON(blocks[i] < blocks[i - 1]);
 185
 186                 /* create extent item */
 187                 itemoff = itemoff - sizeof(struct btrfs_extent_item);
 188                 btrfs_set_disk_key_objectid(&disk_key, blocks[i]);
 189                 btrfs_set_disk_key_offset(&disk_key, leafsize);
 190                 btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_ITEM_KEY);
 191                 btrfs_set_item_key(buf, &disk_key, nritems);
 192                 btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems),
 193                                       itemoff);
 194                 btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 195                                     sizeof(struct btrfs_extent_item));
 196                 extent_item = btrfs_item_ptr(buf, nritems,
 197                                              struct btrfs_extent_item);
 198                 btrfs_set_extent_refs(buf, extent_item, 1);
 199                 nritems++;
 200
 201                 /* create extent ref */
 202                 ref_root = reference_root_table[i];
 203                 if (ref_root == BTRFS_FS_TREE_OBJECTID)
 204                         ref_gen = 1;
 205                 else
 206                         ref_gen = 0;
 207
 208                 hash = btrfs_hash_extent_ref(ref_root, ref_gen, 0, 0);
 209                 itemoff = itemoff - sizeof(struct btrfs_extent_ref);
 210                 btrfs_set_disk_key_objectid(&disk_key, blocks[i]);
 211                 btrfs_set_disk_key_offset(&disk_key, hash);
 212                 btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_REF_KEY);
 213                 btrfs_set_item_key(buf, &disk_key, nritems);
 214                 btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems),
 215                                       itemoff);
 216                 btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems),
 217                                     sizeof(struct btrfs_extent_ref));
 218                 extent_ref = btrfs_item_ptr(buf, nritems,
 219                                              struct btrfs_extent_ref);
 220                 btrfs_set_ref_root(buf, extent_ref, ref_root);
 221                 btrfs_set_ref_generation(buf, extent_ref, ref_gen);
 222                 btrfs_set_ref_objectid(buf, extent_ref, 0);
 223                 btrfs_set_ref_offset(buf, extent_ref, 0);
 224                 nritems++;
 225         }
 226         btrfs_set_header_bytenr(buf, blocks[2]);
 227         btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID);
 228         btrfs_set_header_nritems(buf, nritems);
 229         ret = pwrite(fd, buf->data, leafsize, blocks[2]);
 230         BUG_ON(ret != leafsize);
 231
 232         /* create the chunk tree */
 233         nritems = 0;
 234         item_size = btrfs_chunk_item_size(1);
 235         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) - item_size;
 236
 237         /* first we have chunk 0 */
 238         btrfs_set_disk_key_objectid(&disk_key, 0);
 239         btrfs_set_disk_key_offset(&disk_key, BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 240         btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY);
 241         btrfs_set_item_key(buf, &disk_key, nritems);
 242         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 243         btrfs_set_item_size(buf, btrfs_item_nr(buf,  nritems), item_size);
 244
 245         chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk);
 246         btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID);
 247         btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024);
 248         btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM);
 249         btrfs_set_chunk_io_align(buf, chunk, sectorsize);
 250         btrfs_set_chunk_io_width(buf, chunk, sectorsize);
 251         btrfs_set_chunk_sector_size(buf, chunk, sectorsize);
 252         btrfs_set_chunk_num_stripes(buf, chunk, 1);
 253         btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
 254         btrfs_set_stripe_offset_nr(buf, chunk, 0, 0);
 255
 256         /* copy the key for the chunk to the system array */
 257         ptr = super.sys_chunk_array;
 258         array_size = sizeof(disk_key);
 259
 260         memcpy(ptr, &disk_key, sizeof(disk_key));
 261         ptr += sizeof(disk_key);
 262
 263         /* copy the chunk to the system array */
 264         read_extent_buffer(buf, ptr, (unsigned long)chunk, item_size);
 265         array_size += item_size;
 266         ptr += item_size;
 267         btrfs_set_super_sys_array_size(&super, array_size);
 268
 269         /* then device 1 (there is no device 0) */
 270         nritems++;
 271         item_size = sizeof(*dev_item);
 272         itemoff = itemoff - item_size;
 273         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
 274         btrfs_set_disk_key_offset(&disk_key, 1);
 275         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY);
 276         btrfs_set_item_key(buf, &disk_key, nritems);
 277         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 278         btrfs_set_item_size(buf, btrfs_item_nr(buf, nritems), item_size);
 279
 280         dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item);
 281         btrfs_set_device_id(buf, dev_item, 1);
 282         btrfs_set_device_total_bytes(buf, dev_item, num_bytes);
 283         btrfs_set_device_bytes_used(buf, dev_item,
 284                                     BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 285         btrfs_set_device_io_align(buf, dev_item, sectorsize);
 286         btrfs_set_device_io_width(buf, dev_item, sectorsize);
 287         btrfs_set_device_sector_size(buf, dev_item, sectorsize);
 288         btrfs_set_device_type(buf, dev_item, 0);
 289         nritems++;
 290
 291         uuid_generate(super.dev_item.uuid);
 292
 293         write_extent_buffer(buf, super.dev_item.uuid,
 294                             (unsigned long)btrfs_device_uuid(dev_item),
 295                             BTRFS_DEV_UUID_SIZE);
 296         read_extent_buffer(buf, &super.dev_item, (unsigned long)dev_item,
 297                            sizeof(*dev_item));
 298
 299         btrfs_set_header_bytenr(buf, blocks[3]);
 300         btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID);
 301         btrfs_set_header_nritems(buf, nritems);
 302         ret = pwrite(fd, buf->data, leafsize, blocks[3]);
 303
 304         /* create the device tree */
 305         nritems = 0;
 306         itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) -
 307                 sizeof(struct btrfs_dev_extent);
 308
 309         btrfs_set_disk_key_objectid(&disk_key, 1);
 310         btrfs_set_disk_key_offset(&disk_key, 0);
 311         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY);
 312         btrfs_set_item_key(buf, &disk_key, nritems);
 313         btrfs_set_item_offset(buf, btrfs_item_nr(buf, nritems), itemoff);
 314         btrfs_set_item_size(buf, btrfs_item_nr(buf,  nritems),
 315                             sizeof(struct btrfs_dev_extent));
 316         dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent);
 317         btrfs_set_dev_extent_owner(buf, dev_extent, 0);
 318         btrfs_set_dev_extent_length(buf, dev_extent,
 319                                     BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 320         nritems++;
 321
 322         btrfs_set_header_bytenr(buf, blocks[4]);
 323         btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID);
 324         btrfs_set_header_nritems(buf, nritems);
 325         ret = pwrite(fd, buf->data, leafsize, blocks[4]);
 326
 327         /* finally create the FS root */
 328         btrfs_set_header_bytenr(buf, blocks[5]);
 329         btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID);
 330         btrfs_set_header_nritems(buf, 0);
 331         ret = pwrite(fd, buf->data, leafsize, blocks[5]);
 332         BUG_ON(ret != leafsize);
 333
 334         /* and write out the super block */
 335         BUG_ON(sizeof(super) > sectorsize);
 336         memset(buf->data, 0, sectorsize);
 337         memcpy(buf->data, &super, sizeof(super));
 338         ret = pwrite(fd, buf->data, sectorsize, blocks[0]);
 339         BUG_ON(ret != sectorsize);
 340
 341
 342         free(buf);
 343         return 0;
 344 }
 345
 346 static u64 device_size(int fd, struct stat *st)
 347 {
 348         u64 size;
 349         if (S_ISREG(st->st_mode)) {
 350                 return st->st_size;
 351         }
 352         if (!S_ISBLK(st->st_mode)) {
 353                 return 0;
 354         }
 355         if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
 356                 return size;
 357         }
 358         return 0;
 359 }
 360
 361 static int zero_blocks(int fd, off_t start, size_t len)
 362 {
 363         char *buf = malloc(len);
 364         int ret = 0;
 365         ssize_t written;
 366
 367         if (!buf)
 368                 return -ENOMEM;
 369         memset(buf, 0, len);
 370         written = pwrite(fd, buf, len, start);
 371         if (written != len)
 372                 ret = -EIO;
 373         free(buf);
 374         return ret;
 375 }
 376
 377 static int zero_dev_start(int fd)
 378 {
 379         off_t start = 0;
 380         size_t len = 2 * 1024 * 1024;
 381
 382 #ifdef __sparc__
 383         /* don't overwrite the disk labels on sparc */
 384         start = 1024;
 385         len -= 1024;
 386 #endif
 387         return zero_blocks(fd, start, len);
 388 }
 389
 390 static int zero_dev_end(int fd, u64 dev_size)
 391 {
 392         size_t len = 2 * 1024 * 1024;
 393         off_t start = dev_size - len;
 394
 395         return zero_blocks(fd, start, len);
 396 }
 397
 398 int btrfs_add_to_fsid(struct btrfs_trans_handle *trans,
 399                       struct btrfs_root *root, int fd, u64 block_count,
 400                       u32 io_width, u32 io_align, u32 sectorsize)
 401 {
 402         struct btrfs_super_block *disk_super;
 403         struct btrfs_super_block *super = &root->fs_info->super_copy;
 404         struct btrfs_device device;
 405         struct btrfs_dev_item *dev_item;
 406         char *buf;
 407         u64 total_bytes;
 408         u64 num_devs;
 409         int ret;
 410
 411         buf = malloc(sectorsize);
 412         BUG_ON(sizeof(*disk_super) > sectorsize);
 413         memset(buf, 0, sectorsize);
 414
 415         disk_super = (struct btrfs_super_block *)buf;
 416         dev_item = &disk_super->dev_item;
 417
 418         uuid_generate(device.uuid);
 419         device.devid = 0;
 420         device.type = 0;
 421         device.io_width = io_width;
 422         device.io_align = io_align;
 423         device.sector_size = sectorsize;
 424         device.fd = 0;
 425         device.total_bytes = block_count;
 426         device.bytes_used = 0;
 427
 428         ret = btrfs_add_device(trans, root, &device);
 429         BUG_ON(ret);
 430
 431         total_bytes = btrfs_super_total_bytes(super) + block_count;
 432         btrfs_set_super_total_bytes(super, total_bytes);
 433
 434         num_devs = btrfs_super_num_devices(super) + 1;
 435         btrfs_set_super_num_devices(super, num_devs);
 436
 437         memcpy(disk_super, super, sizeof(*disk_super));
 438
 439         printf("adding device id %Lu\n", device.devid);
 440         btrfs_set_stack_device_id(dev_item, device.devid);
 441         btrfs_set_stack_device_type(dev_item, device.type);
 442         btrfs_set_stack_device_io_align(dev_item, device.io_align);
 443         btrfs_set_stack_device_io_width(dev_item, device.io_width);
 444         btrfs_set_stack_device_sector_size(dev_item, device.sector_size);
 445         btrfs_set_stack_device_total_bytes(dev_item, device.total_bytes);
 446         btrfs_set_stack_device_bytes_used(dev_item, device.bytes_used);
 447         memcpy(&dev_item->uuid, device.uuid, BTRFS_DEV_UUID_SIZE);
 448
 449         ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
 450         BUG_ON(ret != sectorsize);
 451
 452         free(buf);
 453         return 0;
 454 }
 455
 456 int btrfs_prepare_device(int fd, char *file, int zero_end, u64 *block_count_ret)
 457 {
 458         u64 block_count;
 459         struct stat st;
 460         int ret;
 461
 462         ret = fstat(fd, &st);
 463         if (ret < 0) {
 464                 fprintf(stderr, "unable to stat %s\n", file);
 465                 exit(1);
 466         }
 467
 468         block_count = device_size(fd, &st);
 469         if (block_count == 0) {
 470                 fprintf(stderr, "unable to find %s size\n", file);
 471                 exit(1);
 472         }
 473         zero_end = 1;
 474
 475         if (block_count < 256 * 1024 * 1024) {
 476                 fprintf(stderr, "device %s is too small\n", file);
 477                 exit(1);
 478         }
 479         ret = zero_dev_start(fd);
 480         if (ret) {
 481                 fprintf(stderr, "failed to zero device start %d\n", ret);
 482                 exit(1);
 483         }
 484
 485         if (zero_end) {
 486                 ret = zero_dev_end(fd, block_count);
 487                 if (ret) {
 488                         fprintf(stderr, "failed to zero device end %d\n", ret);
 489                         exit(1);
 490                 }
 491         }
 492         *block_count_ret = block_count;
 493         return 0;
 494 }
 495
 496 int btrfs_make_root_dir(struct btrfs_trans_handle *trans,
 497                         struct btrfs_root *root, u64 objectid)
 498 {
 499         int ret;
 500         struct btrfs_inode_item inode_item;
 501
 502         memset(&inode_item, 0, sizeof(inode_item));
 503         btrfs_set_stack_inode_generation(&inode_item, trans->transid);
 504         btrfs_set_stack_inode_size(&inode_item, 0);
 505         btrfs_set_stack_inode_nlink(&inode_item, 1);
 506         btrfs_set_stack_inode_nblocks(&inode_item, 1);
 507         btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0555);
 508
 509         if (root->fs_info->tree_root == root)
 510                 btrfs_set_super_root_dir(&root->fs_info->super_copy, objectid);
 511
 512         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
 513         if (ret)
 514                 goto error;
 515
 516         ret = btrfs_insert_inode_ref(trans, root, "..", 2, objectid, objectid);
 517         if (ret)
 518                 goto error;
 519
 520         btrfs_set_root_dirid(&root->root_item, objectid);
 521         ret = 0;
 522 error:
 523         return ret;
 524 }