utils.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  * Copyright (C) 2008 Morey Roof.  All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public
   7  * License v2 as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 021110-1307, USA.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/mount.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <uuid/uuid.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <mntent.h>
  31 #include <ctype.h>
  32 #include <linux/loop.h>
  33 #include <linux/major.h>
  34 #include <linux/kdev_t.h>
  35 #include <limits.h>
  36 #include <blkid/blkid.h>
  37 #include <sys/vfs.h>
  38 #include <sys/statfs.h>
  39 #include <linux/magic.h>
  40 #include <getopt.h>
  41
  42 #include "kerncompat.h"
  43 #include "radix-tree.h"
  44 #include "ctree.h"
  45 #include "disk-io.h"
  46 #include "transaction.h"
  47 #include "crc32c.h"
  48 #include "utils.h"
  49 #include "volumes.h"
  50 #include "ioctl.h"
  51 #include "commands.h"
  52
  53 #ifndef BLKDISCARD
  54 #define BLKDISCARD      _IO(0x12,119)
  55 #endif
  56
  57 static int btrfs_scan_done = 0;
  58
  59 static char argv0_buf[ARGV0_BUF_SIZE] = "btrfs";
  60
  61 static int rand_seed_initlized = 0;
  62 static unsigned short rand_seed[3];
  63
  64 const char *get_argv0_buf(void)
  65 {
  66         return argv0_buf;
  67 }
  68
  69 void fixup_argv0(char **argv, const char *token)
  70 {
  71         int len = strlen(argv0_buf);
  72
  73         snprintf(argv0_buf + len, sizeof(argv0_buf) - len, " %s", token);
  74         argv[0] = argv0_buf;
  75 }
  76
  77 void set_argv0(char **argv)
  78 {
  79         strncpy(argv0_buf, argv[0], sizeof(argv0_buf));
  80         argv0_buf[sizeof(argv0_buf) - 1] = 0;
  81 }
  82
  83 int check_argc_exact(int nargs, int expected)
  84 {
  85         if (nargs < expected)
  86                 fprintf(stderr, "%s: too few arguments\n", argv0_buf);
  87         if (nargs > expected)
  88                 fprintf(stderr, "%s: too many arguments\n", argv0_buf);
  89
  90         return nargs != expected;
  91 }
  92
  93 int check_argc_min(int nargs, int expected)
  94 {
  95         if (nargs < expected) {
  96                 fprintf(stderr, "%s: too few arguments\n", argv0_buf);
  97                 return 1;
  98         }
  99
 100         return 0;
 101 }
 102
 103 int check_argc_max(int nargs, int expected)
 104 {
 105         if (nargs > expected) {
 106                 fprintf(stderr, "%s: too many arguments\n", argv0_buf);
 107                 return 1;
 108         }
 109
 110         return 0;
 111 }
 112
 113
 114 /*
 115  * Discard the given range in one go
 116  */
 117 static int discard_range(int fd, u64 start, u64 len)
 118 {
 119         u64 range[2] = { start, len };
 120
 121         if (ioctl(fd, BLKDISCARD, &range) < 0)
 122                 return errno;
 123         return 0;
 124 }
 125
 126 /*
 127  * Discard blocks in the given range in 1G chunks, the process is interruptible
 128  */
 129 static int discard_blocks(int fd, u64 start, u64 len)
 130 {
 131         while (len > 0) {
 132                 /* 1G granularity */
 133                 u64 chunk_size = min_t(u64, len, 1*1024*1024*1024);
 134                 int ret;
 135
 136                 ret = discard_range(fd, start, chunk_size);
 137                 if (ret)
 138                         return ret;
 139                 len -= chunk_size;
 140                 start += chunk_size;
 141         }
 142
 143         return 0;
 144 }
 145
 146 static u64 reference_root_table[] = {
 147         [1] =   BTRFS_ROOT_TREE_OBJECTID,
 148         [2] =   BTRFS_EXTENT_TREE_OBJECTID,
 149         [3] =   BTRFS_CHUNK_TREE_OBJECTID,
 150         [4] =   BTRFS_DEV_TREE_OBJECTID,
 151         [5] =   BTRFS_FS_TREE_OBJECTID,
 152         [6] =   BTRFS_CSUM_TREE_OBJECTID,
 153 };
 154
 155 int test_uuid_unique(char *fs_uuid)
 156 {
 157         int unique = 1;
 158         blkid_dev_iterate iter = NULL;
 159         blkid_dev dev = NULL;
 160         blkid_cache cache = NULL;
 161
 162         if (blkid_get_cache(&cache, NULL) < 0) {
 163                 printf("ERROR: lblkid cache get failed\n");
 164                 return 1;
 165         }
 166         blkid_probe_all(cache);
 167         iter = blkid_dev_iterate_begin(cache);
 168         blkid_dev_set_search(iter, "UUID", fs_uuid);
 169
 170         while (blkid_dev_next(iter, &dev) == 0) {
 171                 dev = blkid_verify(cache, dev);
 172                 if (dev) {
 173                         unique = 0;
 174                         break;
 175                 }
 176         }
 177
 178         blkid_dev_iterate_end(iter);
 179         blkid_put_cache(cache);
 180
 181         return unique;
 182 }
 183
 184 /*
 185  * Reserve space from free_tree.
 186  * The algorithm is very simple, find the first cache_extent with enough space
 187  * and allocate from its beginning.
 188  */
 189 static int reserve_free_space(struct cache_tree *free_tree, u64 len,
 190                               u64 *ret_start)
 191 {
 192         struct cache_extent *cache;
 193         int found = 0;
 194
 195         ASSERT(ret_start != NULL);
 196         cache = first_cache_extent(free_tree);
 197         while (cache) {
 198                 if (cache->size > len) {
 199                         found = 1;
 200                         *ret_start = cache->start;
 201
 202                         cache->size -= len;
 203                         if (cache->size == 0) {
 204                                 remove_cache_extent(free_tree, cache);
 205                                 free(cache);
 206                         } else {
 207                                 cache->start += len;
 208                         }
 209                         break;
 210                 }
 211                 cache = next_cache_extent(cache);
 212         }
 213         if (!found)
 214                 return -ENOSPC;
 215         return 0;
 216 }
 217
 218 static inline int write_temp_super(int fd, struct btrfs_super_block *sb,
 219                                    u64 sb_bytenr)
 220 {
 221         u32 crc = ~(u32)0;
 222         int ret;
 223
 224         crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
 225                               BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
 226         btrfs_csum_final(crc, (char *)&sb->csum[0]);
 227         ret = pwrite(fd, sb, BTRFS_SUPER_INFO_SIZE, sb_bytenr);
 228         if (ret < BTRFS_SUPER_INFO_SIZE)
 229                 ret = (ret < 0 ? -errno : -EIO);
 230         else
 231                 ret = 0;
 232         return ret;
 233 }
 234
 235 /*
 236  * Setup temporary superblock at cfg->super_bynter
 237  * Needed info are extracted from cfg, and root_bytenr, chunk_bytenr
 238  *
 239  * For now sys chunk array will be empty and dev_item is empty too.
 240  * They will be re-initialized at temp chunk tree setup.
 241  *
 242  * The superblock signature is not valid, denotes a partially created
 243  * filesystem, needs to be finalized.
 244  */
 245 static int setup_temp_super(int fd, struct btrfs_mkfs_config *cfg,
 246                             u64 root_bytenr, u64 chunk_bytenr)
 247 {
 248         unsigned char chunk_uuid[BTRFS_UUID_SIZE];
 249         char super_buf[BTRFS_SUPER_INFO_SIZE];
 250         struct btrfs_super_block *super = (struct btrfs_super_block *)super_buf;
 251         int ret;
 252
 253         memset(super_buf, 0, BTRFS_SUPER_INFO_SIZE);
 254         cfg->num_bytes = round_down(cfg->num_bytes, cfg->sectorsize);
 255
 256         if (*cfg->fs_uuid) {
 257                 if (uuid_parse(cfg->fs_uuid, super->fsid) != 0) {
 258                         error("cound not parse UUID: %s", cfg->fs_uuid);
 259                         ret = -EINVAL;
 260                         goto out;
 261                 }
 262                 if (!test_uuid_unique(cfg->fs_uuid)) {
 263                         error("non-unique UUID: %s", cfg->fs_uuid);
 264                         ret = -EINVAL;
 265                         goto out;
 266                 }
 267         } else {
 268                 uuid_generate(super->fsid);
 269                 uuid_unparse(super->fsid, cfg->fs_uuid);
 270         }
 271         uuid_generate(chunk_uuid);
 272         uuid_unparse(chunk_uuid, cfg->chunk_uuid);
 273
 274         btrfs_set_super_bytenr(super, cfg->super_bytenr);
 275         btrfs_set_super_num_devices(super, 1);
 276         btrfs_set_super_magic(super, BTRFS_MAGIC_PARTIAL);
 277         btrfs_set_super_generation(super, 1);
 278         btrfs_set_super_root(super, root_bytenr);
 279         btrfs_set_super_chunk_root(super, chunk_bytenr);
 280         btrfs_set_super_total_bytes(super, cfg->num_bytes);
 281         /*
 282          * Temporary filesystem will only have 6 tree roots:
 283          * chunk tree, root tree, extent_tree, device tree, fs tree
 284          * and csum tree.
 285          */
 286         btrfs_set_super_bytes_used(super, 6 * cfg->nodesize);
 287         btrfs_set_super_sectorsize(super, cfg->sectorsize);
 288         btrfs_set_super_leafsize(super, cfg->nodesize);
 289         btrfs_set_super_nodesize(super, cfg->nodesize);
 290         btrfs_set_super_stripesize(super, cfg->stripesize);
 291         btrfs_set_super_csum_type(super, BTRFS_CSUM_TYPE_CRC32);
 292         btrfs_set_super_chunk_root(super, chunk_bytenr);
 293         btrfs_set_super_cache_generation(super, -1);
 294         btrfs_set_super_incompat_flags(super, cfg->features);
 295         if (cfg->label)
 296                 __strncpy_null(super->label, cfg->label, BTRFS_LABEL_SIZE - 1);
 297
 298         /* Sys chunk array will be re-initialized at chunk tree init time */
 299         super->sys_chunk_array_size = 0;
 300
 301         ret = write_temp_super(fd, super, cfg->super_bytenr);
 302 out:
 303         return ret;
 304 }
 305
 306 /*
 307  * Setup an extent buffer for tree block.
 308  */
 309 static int setup_temp_extent_buffer(struct extent_buffer *buf,
 310                                     struct btrfs_mkfs_config *cfg,
 311                                     u64 bytenr, u64 owner)
 312 {
 313         unsigned char fsid[BTRFS_FSID_SIZE];
 314         unsigned char chunk_uuid[BTRFS_UUID_SIZE];
 315         int ret;
 316
 317         ret = uuid_parse(cfg->fs_uuid, fsid);
 318         if (ret)
 319                 return -EINVAL;
 320         ret = uuid_parse(cfg->chunk_uuid, chunk_uuid);
 321         if (ret)
 322                 return -EINVAL;
 323
 324         memset(buf->data, 0, cfg->nodesize);
 325         buf->len = cfg->nodesize;
 326         btrfs_set_header_bytenr(buf, bytenr);
 327         btrfs_set_header_generation(buf, 1);
 328         btrfs_set_header_backref_rev(buf, BTRFS_MIXED_BACKREF_REV);
 329         btrfs_set_header_owner(buf, owner);
 330         btrfs_set_header_flags(buf, BTRFS_HEADER_FLAG_WRITTEN);
 331         write_extent_buffer(buf, chunk_uuid, btrfs_header_chunk_tree_uuid(buf),
 332                             BTRFS_UUID_SIZE);
 333         write_extent_buffer(buf, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
 334         return 0;
 335 }
 336
 337 static inline int write_temp_extent_buffer(int fd, struct extent_buffer *buf,
 338                                            u64 bytenr)
 339 {
 340         int ret;
 341
 342         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
 343
 344         /* Temporary extent buffer is always mapped 1:1 on disk */
 345         ret = pwrite(fd, buf->data, buf->len, bytenr);
 346         if (ret < buf->len)
 347                 ret = (ret < 0 ? ret : -EIO);
 348         else
 349                 ret = 0;
 350         return ret;
 351 }
 352
 353 /*
 354  * Insert a root item for temporary tree root
 355  *
 356  * Only used in make_btrfs_v2().
 357  */
 358 static void insert_temp_root_item(struct extent_buffer *buf,
 359                                   struct btrfs_mkfs_config *cfg,
 360                                   int *slot, u32 *itemoff, u64 objectid,
 361                                   u64 bytenr)
 362 {
 363         struct btrfs_root_item root_item;
 364         struct btrfs_inode_item *inode_item;
 365         struct btrfs_disk_key disk_key;
 366
 367         btrfs_set_header_nritems(buf, *slot + 1);
 368         (*itemoff) -= sizeof(root_item);
 369         memset(&root_item, 0, sizeof(root_item));
 370         inode_item = &root_item.inode;
 371         btrfs_set_stack_inode_generation(inode_item, 1);
 372         btrfs_set_stack_inode_size(inode_item, 3);
 373         btrfs_set_stack_inode_nlink(inode_item, 1);
 374         btrfs_set_stack_inode_nbytes(inode_item, cfg->nodesize);
 375         btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
 376         btrfs_set_root_refs(&root_item, 1);
 377         btrfs_set_root_used(&root_item, cfg->nodesize);
 378         btrfs_set_root_generation(&root_item, 1);
 379         btrfs_set_root_bytenr(&root_item, bytenr);
 380
 381         memset(&disk_key, 0, sizeof(disk_key));
 382         btrfs_set_disk_key_type(&disk_key, BTRFS_ROOT_ITEM_KEY);
 383         btrfs_set_disk_key_objectid(&disk_key, objectid);
 384         btrfs_set_disk_key_offset(&disk_key, 0);
 385
 386         btrfs_set_item_key(buf, &disk_key, *slot);
 387         btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
 388         btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(root_item));
 389         write_extent_buffer(buf, &root_item,
 390                             btrfs_item_ptr_offset(buf, *slot),
 391                             sizeof(root_item));
 392         (*slot)++;
 393 }
 394
 395 static int setup_temp_root_tree(int fd, struct btrfs_mkfs_config *cfg,
 396                                 u64 root_bytenr, u64 extent_bytenr,
 397                                 u64 dev_bytenr, u64 fs_bytenr, u64 csum_bytenr)
 398 {
 399         struct extent_buffer *buf = NULL;
 400         u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
 401         int slot = 0;
 402         int ret;
 403
 404         /*
 405          * Provided bytenr must in ascending order, or tree root will have a
 406          * bad key order.
 407          */
 408         if (!(root_bytenr < extent_bytenr && extent_bytenr < dev_bytenr &&
 409               dev_bytenr < fs_bytenr && fs_bytenr < csum_bytenr)) {
 410                 error("bad tree bytenr order: "
 411                                 "root < extent %llu < %llu, "
 412                                 "extent < dev %llu < %llu, "
 413                                 "dev < fs %llu < %llu, "
 414                                 "fs < csum %llu < %llu",
 415                                 (unsigned long long)root_bytenr,
 416                                 (unsigned long long)extent_bytenr,
 417                                 (unsigned long long)extent_bytenr,
 418                                 (unsigned long long)dev_bytenr,
 419                                 (unsigned long long)dev_bytenr,
 420                                 (unsigned long long)fs_bytenr,
 421                                 (unsigned long long)fs_bytenr,
 422                                 (unsigned long long)csum_bytenr);
 423                 return -EINVAL;
 424         }
 425         buf = malloc(sizeof(*buf) + cfg->nodesize);
 426         if (!buf)
 427                 return -ENOMEM;
 428
 429         ret = setup_temp_extent_buffer(buf, cfg, root_bytenr,
 430                                        BTRFS_ROOT_TREE_OBJECTID);
 431         if (ret < 0)
 432                 goto out;
 433
 434         insert_temp_root_item(buf, cfg, &slot, &itemoff,
 435                               BTRFS_EXTENT_TREE_OBJECTID, extent_bytenr);
 436         insert_temp_root_item(buf, cfg, &slot, &itemoff,
 437                               BTRFS_DEV_TREE_OBJECTID, dev_bytenr);
 438         insert_temp_root_item(buf, cfg, &slot, &itemoff,
 439                               BTRFS_FS_TREE_OBJECTID, fs_bytenr);
 440         insert_temp_root_item(buf, cfg, &slot, &itemoff,
 441                               BTRFS_CSUM_TREE_OBJECTID, csum_bytenr);
 442
 443         ret = write_temp_extent_buffer(fd, buf, root_bytenr);
 444 out:
 445         free(buf);
 446         return ret;
 447 }
 448
 449 static int insert_temp_dev_item(int fd, struct extent_buffer *buf,
 450                                 struct btrfs_mkfs_config *cfg,
 451                                 int *slot, u32 *itemoff)
 452 {
 453         struct btrfs_disk_key disk_key;
 454         struct btrfs_dev_item *dev_item;
 455         char super_buf[BTRFS_SUPER_INFO_SIZE];
 456         unsigned char dev_uuid[BTRFS_UUID_SIZE];
 457         unsigned char fsid[BTRFS_FSID_SIZE];
 458         struct btrfs_super_block *super = (struct btrfs_super_block *)super_buf;
 459         int ret;
 460
 461         ret = pread(fd, super_buf, BTRFS_SUPER_INFO_SIZE, cfg->super_bytenr);
 462         if (ret < BTRFS_SUPER_INFO_SIZE) {
 463                 ret = (ret < 0 ? -errno : -EIO);
 464                 goto out;
 465         }
 466
 467         btrfs_set_header_nritems(buf, *slot + 1);
 468         (*itemoff) -= sizeof(*dev_item);
 469         /* setup device item 1, 0 is for replace case */
 470         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY);
 471         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
 472         btrfs_set_disk_key_offset(&disk_key, 1);
 473         btrfs_set_item_key(buf, &disk_key, *slot);
 474         btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
 475         btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(*dev_item));
 476
 477         dev_item = btrfs_item_ptr(buf, *slot, struct btrfs_dev_item);
 478         /* Generate device uuid */
 479         uuid_generate(dev_uuid);
 480         write_extent_buffer(buf, dev_uuid,
 481                         (unsigned long)btrfs_device_uuid(dev_item),
 482                         BTRFS_UUID_SIZE);
 483         uuid_parse(cfg->fs_uuid, fsid);
 484         write_extent_buffer(buf, fsid,
 485                         (unsigned long)btrfs_device_fsid(dev_item),
 486                         BTRFS_FSID_SIZE);
 487         btrfs_set_device_id(buf, dev_item, 1);
 488         btrfs_set_device_generation(buf, dev_item, 0);
 489         btrfs_set_device_total_bytes(buf, dev_item, cfg->num_bytes);
 490         /*
 491          * The number must match the initial SYSTEM and META chunk size
 492          */
 493         btrfs_set_device_bytes_used(buf, dev_item,
 494                         BTRFS_MKFS_SYSTEM_GROUP_SIZE +
 495                         BTRFS_CONVERT_META_GROUP_SIZE);
 496         btrfs_set_device_io_align(buf, dev_item, cfg->sectorsize);
 497         btrfs_set_device_io_width(buf, dev_item, cfg->sectorsize);
 498         btrfs_set_device_sector_size(buf, dev_item, cfg->sectorsize);
 499         btrfs_set_device_type(buf, dev_item, 0);
 500
 501         /* Super dev_item is not complete, copy the complete one to sb */
 502         read_extent_buffer(buf, &super->dev_item, (unsigned long)dev_item,
 503                            sizeof(*dev_item));
 504         ret = write_temp_super(fd, super, cfg->super_bytenr);
 505         (*slot)++;
 506 out:
 507         return ret;
 508 }
 509
 510 static int insert_temp_chunk_item(int fd, struct extent_buffer *buf,
 511                                   struct btrfs_mkfs_config *cfg,
 512                                   int *slot, u32 *itemoff, u64 start, u64 len,
 513                                   u64 type)
 514 {
 515         struct btrfs_chunk *chunk;
 516         struct btrfs_disk_key disk_key;
 517         char super_buf[BTRFS_SUPER_INFO_SIZE];
 518         struct btrfs_super_block *sb = (struct btrfs_super_block *)super_buf;
 519         int ret = 0;
 520
 521         ret = pread(fd, super_buf, BTRFS_SUPER_INFO_SIZE,
 522                     cfg->super_bytenr);
 523         if (ret < BTRFS_SUPER_INFO_SIZE) {
 524                 ret = (ret < 0 ? ret : -EIO);
 525                 return ret;
 526         }
 527
 528         btrfs_set_header_nritems(buf, *slot + 1);
 529         (*itemoff) -= btrfs_chunk_item_size(1);
 530         btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY);
 531         btrfs_set_disk_key_objectid(&disk_key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 532         btrfs_set_disk_key_offset(&disk_key, start);
 533         btrfs_set_item_key(buf, &disk_key, *slot);
 534         btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
 535         btrfs_set_item_size(buf, btrfs_item_nr(*slot),
 536                             btrfs_chunk_item_size(1));
 537
 538         chunk = btrfs_item_ptr(buf, *slot, struct btrfs_chunk);
 539         btrfs_set_chunk_length(buf, chunk, len);
 540         btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID);
 541         btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024);
 542         btrfs_set_chunk_type(buf, chunk, type);
 543         btrfs_set_chunk_io_align(buf, chunk, cfg->sectorsize);
 544         btrfs_set_chunk_io_width(buf, chunk, cfg->sectorsize);
 545         btrfs_set_chunk_sector_size(buf, chunk, cfg->sectorsize);
 546         btrfs_set_chunk_num_stripes(buf, chunk, 1);
 547         /* TODO: Support DUP profile for system chunk */
 548         btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
 549         /* We are doing 1:1 mapping, so start is its dev offset */
 550         btrfs_set_stripe_offset_nr(buf, chunk, 0, start);
 551         write_extent_buffer(buf, &sb->dev_item.uuid,
 552                             (unsigned long)btrfs_stripe_dev_uuid_nr(chunk, 0),
 553                             BTRFS_UUID_SIZE);
 554         (*slot)++;
 555
 556         /*
 557          * If it's system chunk, also copy it to super block.
 558          */
 559         if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
 560                 char *cur;
 561
 562                 cur = (char *)sb->sys_chunk_array + sb->sys_chunk_array_size;
 563                 memcpy(cur, &disk_key, sizeof(disk_key));
 564                 cur += sizeof(disk_key);
 565                 read_extent_buffer(buf, cur, (unsigned long int)chunk,
 566                                    btrfs_chunk_item_size(1));
 567                 sb->sys_chunk_array_size += btrfs_chunk_item_size(1) +
 568                                             sizeof(disk_key);
 569
 570                 ret = write_temp_super(fd, sb, cfg->super_bytenr);
 571         }
 572         return ret;
 573 }
 574
 575 static int setup_temp_chunk_tree(int fd, struct btrfs_mkfs_config *cfg,
 576                                  u64 sys_chunk_start, u64 meta_chunk_start,
 577                                  u64 chunk_bytenr)
 578 {
 579         struct extent_buffer *buf = NULL;
 580         u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
 581         int slot = 0;
 582         int ret;
 583
 584         /* Must ensure SYS chunk starts before META chunk */
 585         if (meta_chunk_start < sys_chunk_start) {
 586                 error("wrong chunk order: meta < system %llu < %llu",
 587                                 (unsigned long long)meta_chunk_start,
 588                                 (unsigned long long)sys_chunk_start);
 589                 return -EINVAL;
 590         }
 591         buf = malloc(sizeof(*buf) + cfg->nodesize);
 592         if (!buf)
 593                 return -ENOMEM;
 594         ret = setup_temp_extent_buffer(buf, cfg, chunk_bytenr,
 595                                        BTRFS_CHUNK_TREE_OBJECTID);
 596         if (ret < 0)
 597                 goto out;
 598
 599         ret = insert_temp_dev_item(fd, buf, cfg, &slot, &itemoff);
 600         if (ret < 0)
 601                 goto out;
 602         ret = insert_temp_chunk_item(fd, buf, cfg, &slot, &itemoff,
 603                                      sys_chunk_start,
 604                                      BTRFS_MKFS_SYSTEM_GROUP_SIZE,
 605                                      BTRFS_BLOCK_GROUP_SYSTEM);
 606         if (ret < 0)
 607                 goto out;
 608         ret = insert_temp_chunk_item(fd, buf, cfg, &slot, &itemoff,
 609                                      meta_chunk_start,
 610                                      BTRFS_CONVERT_META_GROUP_SIZE,
 611                                      BTRFS_BLOCK_GROUP_METADATA);
 612         if (ret < 0)
 613                 goto out;
 614         ret = write_temp_extent_buffer(fd, buf, chunk_bytenr);
 615
 616 out:
 617         free(buf);
 618         return ret;
 619 }
 620
 621 static void insert_temp_dev_extent(struct extent_buffer *buf,
 622                                    int *slot, u32 *itemoff, u64 start, u64 len)
 623 {
 624         struct btrfs_dev_extent *dev_extent;
 625         struct btrfs_disk_key disk_key;
 626
 627         btrfs_set_header_nritems(buf, *slot + 1);
 628         (*itemoff) -= sizeof(*dev_extent);
 629         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY);
 630         btrfs_set_disk_key_objectid(&disk_key, 1);
 631         btrfs_set_disk_key_offset(&disk_key, start);
 632         btrfs_set_item_key(buf, &disk_key, *slot);
 633         btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
 634         btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(*dev_extent));
 635
 636         dev_extent = btrfs_item_ptr(buf, *slot, struct btrfs_dev_extent);
 637         btrfs_set_dev_extent_chunk_objectid(buf, dev_extent,
 638                                             BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 639         btrfs_set_dev_extent_length(buf, dev_extent, len);
 640         btrfs_set_dev_extent_chunk_offset(buf, dev_extent, start);
 641         btrfs_set_dev_extent_chunk_tree(buf, dev_extent,
 642                                         BTRFS_CHUNK_TREE_OBJECTID);
 643         (*slot)++;
 644 }
 645
 646 static int setup_temp_dev_tree(int fd, struct btrfs_mkfs_config *cfg,
 647                                u64 sys_chunk_start, u64 meta_chunk_start,
 648                                u64 dev_bytenr)
 649 {
 650         struct extent_buffer *buf = NULL;
 651         u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
 652         int slot = 0;
 653         int ret;
 654
 655         /* Must ensure SYS chunk starts before META chunk */
 656         if (meta_chunk_start < sys_chunk_start) {
 657                 error("wrong chunk order: meta < system %llu < %llu",
 658                                 (unsigned long long)meta_chunk_start,
 659                                 (unsigned long long)sys_chunk_start);
 660                 return -EINVAL;
 661         }
 662         buf = malloc(sizeof(*buf) + cfg->nodesize);
 663         if (!buf)
 664                 return -ENOMEM;
 665         ret = setup_temp_extent_buffer(buf, cfg, dev_bytenr,
 666                                        BTRFS_DEV_TREE_OBJECTID);
 667         if (ret < 0)
 668                 goto out;
 669         insert_temp_dev_extent(buf, &slot, &itemoff, sys_chunk_start,
 670                                BTRFS_MKFS_SYSTEM_GROUP_SIZE);
 671         insert_temp_dev_extent(buf, &slot, &itemoff, meta_chunk_start,
 672                                BTRFS_CONVERT_META_GROUP_SIZE);
 673         ret = write_temp_extent_buffer(fd, buf, dev_bytenr);
 674 out:
 675         free(buf);
 676         return ret;
 677 }
 678
 679 static int setup_temp_fs_tree(int fd, struct btrfs_mkfs_config *cfg,
 680                               u64 fs_bytenr)
 681 {
 682         struct extent_buffer *buf = NULL;
 683         int ret;
 684
 685         buf = malloc(sizeof(*buf) + cfg->nodesize);
 686         if (!buf)
 687                 return -ENOMEM;
 688         ret = setup_temp_extent_buffer(buf, cfg, fs_bytenr,
 689                                        BTRFS_FS_TREE_OBJECTID);
 690         if (ret < 0)
 691                 goto out;
 692         /*
 693          * Temporary fs tree is completely empty.
 694          */
 695         ret = write_temp_extent_buffer(fd, buf, fs_bytenr);
 696 out:
 697         free(buf);
 698         return ret;
 699 }
 700
 701 static int setup_temp_csum_tree(int fd, struct btrfs_mkfs_config *cfg,
 702                                 u64 csum_bytenr)
 703 {
 704         struct extent_buffer *buf = NULL;
 705         int ret;
 706
 707         buf = malloc(sizeof(*buf) + cfg->nodesize);
 708         if (!buf)
 709                 return -ENOMEM;
 710         ret = setup_temp_extent_buffer(buf, cfg, csum_bytenr,
 711                                        BTRFS_CSUM_TREE_OBJECTID);
 712         if (ret < 0)
 713                 goto out;
 714         /*
 715          * Temporary csum tree is completely empty.
 716          */
 717         ret = write_temp_extent_buffer(fd, buf, csum_bytenr);
 718 out:
 719         free(buf);
 720         return ret;
 721 }
 722
 723 /*
 724  * Insert one temporary extent item.
 725  *
 726  * NOTE: if skinny_metadata is not enabled, this function must be called
 727  * after all other trees are initialized.
 728  * Or fs without skinny-metadata will be screwed up.
 729  */
 730 static int insert_temp_extent_item(int fd, struct extent_buffer *buf,
 731                                    struct btrfs_mkfs_config *cfg,
 732                                    int *slot, u32 *itemoff, u64 bytenr,
 733                                    u64 ref_root)
 734 {
 735         struct extent_buffer *tmp;
 736         struct btrfs_extent_item *ei;
 737         struct btrfs_extent_inline_ref *iref;
 738         struct btrfs_disk_key disk_key;
 739         struct btrfs_disk_key tree_info_key;
 740         struct btrfs_tree_block_info *info;
 741         int itemsize;
 742         int skinny_metadata = cfg->features &
 743                               BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA;
 744         int ret;
 745
 746         if (skinny_metadata)
 747                 itemsize = sizeof(*ei) + sizeof(*iref);
 748         else
 749                 itemsize = sizeof(*ei) + sizeof(*iref) +
 750                            sizeof(struct btrfs_tree_block_info);
 751
 752         btrfs_set_header_nritems(buf, *slot + 1);
 753         *(itemoff) -= itemsize;
 754
 755         if (skinny_metadata) {
 756                 btrfs_set_disk_key_type(&disk_key, BTRFS_METADATA_ITEM_KEY);
 757                 btrfs_set_disk_key_offset(&disk_key, 0);
 758         } else {
 759                 btrfs_set_disk_key_type(&disk_key, BTRFS_EXTENT_ITEM_KEY);
 760                 btrfs_set_disk_key_offset(&disk_key, cfg->nodesize);
 761         }
 762         btrfs_set_disk_key_objectid(&disk_key, bytenr);
 763
 764         btrfs_set_item_key(buf, &disk_key, *slot);
 765         btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
 766         btrfs_set_item_size(buf, btrfs_item_nr(*slot), itemsize);
 767
 768         ei = btrfs_item_ptr(buf, *slot, struct btrfs_extent_item);
 769         btrfs_set_extent_refs(buf, ei, 1);
 770         btrfs_set_extent_generation(buf, ei, 1);
 771         btrfs_set_extent_flags(buf, ei, BTRFS_EXTENT_FLAG_TREE_BLOCK);
 772
 773         if (skinny_metadata) {
 774                 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
 775         } else {
 776                 info = (struct btrfs_tree_block_info *)(ei + 1);
 777                 iref = (struct btrfs_extent_inline_ref *)(info + 1);
 778         }
 779         btrfs_set_extent_inline_ref_type(buf, iref,
 780                                          BTRFS_TREE_BLOCK_REF_KEY);
 781         btrfs_set_extent_inline_ref_offset(buf, iref, ref_root);
 782
 783         (*slot)++;
 784         if (skinny_metadata)
 785                 return 0;
 786
 787         /*
 788          * Lastly, check the tree block key by read the tree block
 789          * Since we do 1:1 mapping for convert case, we can directly
 790          * read the bytenr from disk
 791          */
 792         tmp = malloc(sizeof(*tmp) + cfg->nodesize);
 793         if (!tmp)
 794                 return -ENOMEM;
 795         ret = setup_temp_extent_buffer(tmp, cfg, bytenr, ref_root);
 796         if (ret < 0)
 797                 goto out;
 798         ret = pread(fd, tmp->data, cfg->nodesize, bytenr);
 799         if (ret < cfg->nodesize) {
 800                 ret = (ret < 0 ? -errno : -EIO);
 801                 goto out;
 802         }
 803         if (btrfs_header_nritems(tmp) == 0) {
 804                 btrfs_set_disk_key_type(&tree_info_key, 0);
 805                 btrfs_set_disk_key_objectid(&tree_info_key, 0);
 806                 btrfs_set_disk_key_offset(&tree_info_key, 0);
 807         } else {
 808                 btrfs_item_key(tmp, &tree_info_key, 0);
 809         }
 810         btrfs_set_tree_block_key(buf, info, &tree_info_key);
 811
 812 out:
 813         free(tmp);
 814         return ret;
 815 }
 816
 817 static void insert_temp_block_group(struct extent_buffer *buf,
 818                                    struct btrfs_mkfs_config *cfg,
 819                                    int *slot, u32 *itemoff,
 820                                    u64 bytenr, u64 len, u64 used, u64 flag)
 821 {
 822         struct btrfs_block_group_item bgi;
 823         struct btrfs_disk_key disk_key;
 824
 825         btrfs_set_header_nritems(buf, *slot + 1);
 826         (*itemoff) -= sizeof(bgi);
 827         btrfs_set_disk_key_type(&disk_key, BTRFS_BLOCK_GROUP_ITEM_KEY);
 828         btrfs_set_disk_key_objectid(&disk_key, bytenr);
 829         btrfs_set_disk_key_offset(&disk_key, len);
 830         btrfs_set_item_key(buf, &disk_key, *slot);
 831         btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
 832         btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(bgi));
 833
 834         btrfs_set_block_group_flags(&bgi, flag);
 835         btrfs_set_block_group_used(&bgi, used);
 836         btrfs_set_block_group_chunk_objectid(&bgi,
 837                         BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 838         write_extent_buffer(buf, &bgi, btrfs_item_ptr_offset(buf, *slot),
 839                             sizeof(bgi));
 840         (*slot)++;
 841 }
 842
 843 static int setup_temp_extent_tree(int fd, struct btrfs_mkfs_config *cfg,
 844                                   u64 chunk_bytenr, u64 root_bytenr,
 845                                   u64 extent_bytenr, u64 dev_bytenr,
 846                                   u64 fs_bytenr, u64 csum_bytenr)
 847 {
 848         struct extent_buffer *buf = NULL;
 849         u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
 850         int slot = 0;
 851         int ret;
 852
 853         /*
 854          * We must ensure provided bytenr are in ascending order,
 855          * or extent tree key order will be broken.
 856          */
 857         if (!(chunk_bytenr < root_bytenr && root_bytenr < extent_bytenr &&
 858               extent_bytenr < dev_bytenr && dev_bytenr < fs_bytenr &&
 859               fs_bytenr < csum_bytenr)) {
 860                 error("bad tree bytenr order: "
 861                                 "chunk < root %llu < %llu, "
 862                                 "root < extent %llu < %llu, "
 863                                 "extent < dev %llu < %llu, "
 864                                 "dev < fs %llu < %llu, "
 865                                 "fs < csum %llu < %llu",
 866                                 (unsigned long long)chunk_bytenr,
 867                                 (unsigned long long)root_bytenr,
 868                                 (unsigned long long)root_bytenr,
 869                                 (unsigned long long)extent_bytenr,
 870                                 (unsigned long long)extent_bytenr,
 871                                 (unsigned long long)dev_bytenr,
 872                                 (unsigned long long)dev_bytenr,
 873                                 (unsigned long long)fs_bytenr,
 874                                 (unsigned long long)fs_bytenr,
 875                                 (unsigned long long)csum_bytenr);
 876                 return -EINVAL;
 877         }
 878         buf = malloc(sizeof(*buf) + cfg->nodesize);
 879         if (!buf)
 880                 return -ENOMEM;
 881
 882         ret = setup_temp_extent_buffer(buf, cfg, extent_bytenr,
 883                                        BTRFS_EXTENT_TREE_OBJECTID);
 884         if (ret < 0)
 885                 goto out;
 886
 887         ret = insert_temp_extent_item(fd, buf, cfg, &slot, &itemoff,
 888                         chunk_bytenr, BTRFS_CHUNK_TREE_OBJECTID);
 889         if (ret < 0)
 890                 goto out;
 891
 892         insert_temp_block_group(buf, cfg, &slot, &itemoff, chunk_bytenr,
 893                         BTRFS_MKFS_SYSTEM_GROUP_SIZE, cfg->nodesize,
 894                         BTRFS_BLOCK_GROUP_SYSTEM);
 895
 896         ret = insert_temp_extent_item(fd, buf, cfg, &slot, &itemoff,
 897                         root_bytenr, BTRFS_ROOT_TREE_OBJECTID);
 898         if (ret < 0)
 899                 goto out;
 900
 901         /* 5 tree block used, root, extent, dev, fs and csum*/
 902         insert_temp_block_group(buf, cfg, &slot, &itemoff, root_bytenr,
 903                         BTRFS_CONVERT_META_GROUP_SIZE, cfg->nodesize * 5,
 904                         BTRFS_BLOCK_GROUP_METADATA);
 905
 906         ret = insert_temp_extent_item(fd, buf, cfg, &slot, &itemoff,
 907                         extent_bytenr, BTRFS_EXTENT_TREE_OBJECTID);
 908         if (ret < 0)
 909                 goto out;
 910         ret = insert_temp_extent_item(fd, buf, cfg, &slot, &itemoff,
 911                         dev_bytenr, BTRFS_DEV_TREE_OBJECTID);
 912         if (ret < 0)
 913                 goto out;
 914         ret = insert_temp_extent_item(fd, buf, cfg, &slot, &itemoff,
 915                         fs_bytenr, BTRFS_FS_TREE_OBJECTID);
 916         if (ret < 0)
 917                 goto out;
 918         ret = insert_temp_extent_item(fd, buf, cfg, &slot, &itemoff,
 919                         csum_bytenr, BTRFS_CSUM_TREE_OBJECTID);
 920         if (ret < 0)
 921                 goto out;
 922
 923         ret = write_temp_extent_buffer(fd, buf, extent_bytenr);
 924 out:
 925         free(buf);
 926         return ret;
 927 }
 928
 929 /*
 930  * Improved version of make_btrfs().
 931  *
 932  * This one will
 933  * 1) Do chunk allocation to avoid used data
 934  *    And after this function, extent type matches chunk type
 935  * 2) Better structured code
 936  *    No super long hand written codes to initialized all tree blocks
 937  *    Split into small blocks and reuse codes.
 938  *    TODO: Reuse tree operation facilities by introducing new flags
 939  */
 940 static int make_convert_btrfs(int fd, struct btrfs_mkfs_config *cfg,
 941                               struct btrfs_convert_context *cctx)
 942 {
 943         struct cache_tree *free = &cctx->free;
 944         struct cache_tree *used = &cctx->used;
 945         u64 sys_chunk_start;
 946         u64 meta_chunk_start;
 947         /* chunk tree bytenr, in system chunk */
 948         u64 chunk_bytenr;
 949         /* metadata trees bytenr, in metadata chunk */
 950         u64 root_bytenr;
 951         u64 extent_bytenr;
 952         u64 dev_bytenr;
 953         u64 fs_bytenr;
 954         u64 csum_bytenr;
 955         int ret;
 956
 957         /* Shouldn't happen */
 958         BUG_ON(cache_tree_empty(used));
 959
 960         /*
 961          * reserve space for temporary superblock first
 962          * Here we allocate a little larger space, to keep later
 963          * free space will be STRIPE_LEN aligned
 964          */
 965         ret = reserve_free_space(free, BTRFS_STRIPE_LEN,
 966                                  &cfg->super_bytenr);
 967         if (ret < 0)
 968                 goto out;
 969
 970         /*
 971          * Then reserve system chunk space
 972          * TODO: Change system group size depending on cctx->total_bytes.
 973          * If using current 4M, it can only handle less than one TB for
 974          * worst case and then run out of sys space.
 975          */
 976         ret = reserve_free_space(free, BTRFS_MKFS_SYSTEM_GROUP_SIZE,
 977                                  &sys_chunk_start);
 978         if (ret < 0)
 979                 goto out;
 980         ret = reserve_free_space(free, BTRFS_CONVERT_META_GROUP_SIZE,
 981                                  &meta_chunk_start);
 982         if (ret < 0)
 983                 goto out;
 984
 985         /*
 986          * Allocated meta/sys chunks will be mapped 1:1 with device offset.
 987          *
 988          * Inside the allocated metadata chunk, the layout will be:
 989          *  | offset            | contents      |
 990          *  -------------------------------------
 991          *  | +0                | tree root     |
 992          *  | +nodesize         | extent root   |
 993          *  | +nodesize * 2     | device root   |
 994          *  | +nodesize * 3     | fs tree       |
 995          *  | +nodesize * 4     | csum tree     |
 996          *  -------------------------------------
 997          * Inside the allocated system chunk, the layout will be:
 998          *  | offset            | contents      |
 999          *  -------------------------------------
1000          *  | +0                | chunk root    |
1001          *  -------------------------------------
1002          */
1003         chunk_bytenr = sys_chunk_start;
1004         root_bytenr = meta_chunk_start;
1005         extent_bytenr = meta_chunk_start + cfg->nodesize;
1006         dev_bytenr = meta_chunk_start + cfg->nodesize * 2;
1007         fs_bytenr = meta_chunk_start + cfg->nodesize * 3;
1008         csum_bytenr = meta_chunk_start + cfg->nodesize * 4;
1009
1010         ret = setup_temp_super(fd, cfg, root_bytenr, chunk_bytenr);
1011         if (ret < 0)
1012                 goto out;
1013
1014         ret = setup_temp_root_tree(fd, cfg, root_bytenr, extent_bytenr,
1015                                    dev_bytenr, fs_bytenr, csum_bytenr);
1016         if (ret < 0)
1017                 goto out;
1018         ret = setup_temp_chunk_tree(fd, cfg, sys_chunk_start, meta_chunk_start,
1019                                     chunk_bytenr);
1020         if (ret < 0)
1021                 goto out;
1022         ret = setup_temp_dev_tree(fd, cfg, sys_chunk_start, meta_chunk_start,
1023                                   dev_bytenr);
1024         if (ret < 0)
1025                 goto out;
1026         ret = setup_temp_fs_tree(fd, cfg, fs_bytenr);
1027         if (ret < 0)
1028                 goto out;
1029         ret = setup_temp_csum_tree(fd, cfg, csum_bytenr);
1030         if (ret < 0)
1031                 goto out;
1032         /*
1033          * Setup extent tree last, since it may need to read tree block key
1034          * for non-skinny metadata case.
1035          */
1036         ret = setup_temp_extent_tree(fd, cfg, chunk_bytenr, root_bytenr,
1037                                      extent_bytenr, dev_bytenr, fs_bytenr,
1038                                      csum_bytenr);
1039 out:
1040         return ret;
1041 }
1042
1043 /*
1044  * @fs_uuid - if NULL, generates a UUID, returns back the new filesystem UUID
1045  *
1046  * The superblock signature is not valid, denotes a partially created
1047  * filesystem, needs to be finalized.
1048  */
1049 int make_btrfs(int fd, struct btrfs_mkfs_config *cfg,
1050                 struct btrfs_convert_context *cctx)
1051 {
1052         struct btrfs_super_block super;
1053         struct extent_buffer *buf;
1054         struct btrfs_root_item root_item;
1055         struct btrfs_disk_key disk_key;
1056         struct btrfs_extent_item *extent_item;
1057         struct btrfs_inode_item *inode_item;
1058         struct btrfs_chunk *chunk;
1059         struct btrfs_dev_item *dev_item;
1060         struct btrfs_dev_extent *dev_extent;
1061         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
1062         u8 *ptr;
1063         int i;
1064         int ret;
1065         u32 itemoff;
1066         u32 nritems = 0;
1067         u64 first_free;
1068         u64 ref_root;
1069         u32 array_size;
1070         u32 item_size;
1071         int skinny_metadata = !!(cfg->features &
1072                                  BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA);
1073         u64 num_bytes;
1074
1075         if (cctx)
1076                 return make_convert_btrfs(fd, cfg, cctx);
1077         buf = malloc(sizeof(*buf) + max(cfg->sectorsize, cfg->nodesize));
1078         if (!buf)
1079                 return -ENOMEM;
1080
1081         first_free = BTRFS_SUPER_INFO_OFFSET + cfg->sectorsize * 2 - 1;
1082         first_free &= ~((u64)cfg->sectorsize - 1);
1083
1084         memset(&super, 0, sizeof(super));
1085
1086         num_bytes = (cfg->num_bytes / cfg->sectorsize) * cfg->sectorsize;
1087         if (*cfg->fs_uuid) {
1088                 if (uuid_parse(cfg->fs_uuid, super.fsid) != 0) {
1089                         error("cannot not parse UUID: %s", cfg->fs_uuid);
1090                         ret = -EINVAL;
1091                         goto out;
1092                 }
1093                 if (!test_uuid_unique(cfg->fs_uuid)) {
1094                         error("non-unique UUID: %s", cfg->fs_uuid);
1095                         ret = -EBUSY;
1096                         goto out;
1097                 }
1098         } else {
1099                 uuid_generate(super.fsid);
1100                 if (cfg->fs_uuid)
1101                         uuid_unparse(super.fsid, cfg->fs_uuid);
1102         }
1103         uuid_generate(super.dev_item.uuid);
1104         uuid_generate(chunk_tree_uuid);
1105
1106         btrfs_set_super_bytenr(&super, cfg->blocks[0]);
1107         btrfs_set_super_num_devices(&super, 1);
1108         btrfs_set_super_magic(&super, BTRFS_MAGIC_PARTIAL);
1109         btrfs_set_super_generation(&super, 1);
1110         btrfs_set_super_root(&super, cfg->blocks[1]);
1111         btrfs_set_super_chunk_root(&super, cfg->blocks[3]);
1112         btrfs_set_super_total_bytes(&super, num_bytes);
1113         btrfs_set_super_bytes_used(&super, 6 * cfg->nodesize);
1114         btrfs_set_super_sectorsize(&super, cfg->sectorsize);
1115         btrfs_set_super_leafsize(&super, cfg->nodesize);
1116         btrfs_set_super_nodesize(&super, cfg->nodesize);
1117         btrfs_set_super_stripesize(&super, cfg->stripesize);
1118         btrfs_set_super_csum_type(&super, BTRFS_CSUM_TYPE_CRC32);
1119         btrfs_set_super_chunk_root_generation(&super, 1);
1120         btrfs_set_super_cache_generation(&super, -1);
1121         btrfs_set_super_incompat_flags(&super, cfg->features);
1122         if (cfg->label)
1123                 __strncpy_null(super.label, cfg->label, BTRFS_LABEL_SIZE - 1);
1124
1125         /* create the tree of root objects */
1126         memset(buf->data, 0, cfg->nodesize);
1127         buf->len = cfg->nodesize;
1128         btrfs_set_header_bytenr(buf, cfg->blocks[1]);
1129         btrfs_set_header_nritems(buf, 4);
1130         btrfs_set_header_generation(buf, 1);
1131         btrfs_set_header_backref_rev(buf, BTRFS_MIXED_BACKREF_REV);
1132         btrfs_set_header_owner(buf, BTRFS_ROOT_TREE_OBJECTID);
1133         write_extent_buffer(buf, super.fsid, btrfs_header_fsid(),
1134                             BTRFS_FSID_SIZE);
1135
1136         write_extent_buffer(buf, chunk_tree_uuid,
1137                             btrfs_header_chunk_tree_uuid(buf),
1138                             BTRFS_UUID_SIZE);
1139
1140         /* create the items for the root tree */
1141         memset(&root_item, 0, sizeof(root_item));
1142         inode_item = &root_item.inode;
1143         btrfs_set_stack_inode_generation(inode_item, 1);
1144         btrfs_set_stack_inode_size(inode_item, 3);
1145         btrfs_set_stack_inode_nlink(inode_item, 1);
1146         btrfs_set_stack_inode_nbytes(inode_item, cfg->nodesize);
1147         btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
1148         btrfs_set_root_refs(&root_item, 1);
1149         btrfs_set_root_used(&root_item, cfg->nodesize);
1150         btrfs_set_root_generation(&root_item, 1);
1151
1152         memset(&disk_key, 0, sizeof(disk_key));
1153         btrfs_set_disk_key_type(&disk_key, BTRFS_ROOT_ITEM_KEY);
1154         btrfs_set_disk_key_offset(&disk_key, 0);
1155         nritems = 0;
1156
1157         itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(root_item);
1158         btrfs_set_root_bytenr(&root_item, cfg->blocks[2]);
1159         btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID);
1160         btrfs_set_item_key(buf, &disk_key, nritems);
1161         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1162         btrfs_set_item_size(buf, btrfs_item_nr(nritems),
1163                             sizeof(root_item));
1164         write_extent_buffer(buf, &root_item, btrfs_item_ptr_offset(buf,
1165                             nritems), sizeof(root_item));
1166         nritems++;
1167
1168         itemoff = itemoff - sizeof(root_item);
1169         btrfs_set_root_bytenr(&root_item, cfg->blocks[4]);
1170         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_TREE_OBJECTID);
1171         btrfs_set_item_key(buf, &disk_key, nritems);
1172         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1173         btrfs_set_item_size(buf, btrfs_item_nr(nritems),
1174                             sizeof(root_item));
1175         write_extent_buffer(buf, &root_item,
1176                             btrfs_item_ptr_offset(buf, nritems),
1177                             sizeof(root_item));
1178         nritems++;
1179
1180         itemoff = itemoff - sizeof(root_item);
1181         btrfs_set_root_bytenr(&root_item, cfg->blocks[5]);
1182         btrfs_set_disk_key_objectid(&disk_key, BTRFS_FS_TREE_OBJECTID);
1183         btrfs_set_item_key(buf, &disk_key, nritems);
1184         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1185         btrfs_set_item_size(buf, btrfs_item_nr(nritems),
1186                             sizeof(root_item));
1187         write_extent_buffer(buf, &root_item,
1188                             btrfs_item_ptr_offset(buf, nritems),
1189                             sizeof(root_item));
1190         nritems++;
1191
1192         itemoff = itemoff - sizeof(root_item);
1193         btrfs_set_root_bytenr(&root_item, cfg->blocks[6]);
1194         btrfs_set_disk_key_objectid(&disk_key, BTRFS_CSUM_TREE_OBJECTID);
1195         btrfs_set_item_key(buf, &disk_key, nritems);
1196         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1197         btrfs_set_item_size(buf, btrfs_item_nr(nritems),
1198                             sizeof(root_item));
1199         write_extent_buffer(buf, &root_item,
1200                             btrfs_item_ptr_offset(buf, nritems),
1201                             sizeof(root_item));
1202         nritems++;
1203
1204
1205         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1206         ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[1]);
1207         if (ret != cfg->nodesize) {
1208                 ret = (ret < 0 ? -errno : -EIO);
1209                 goto out;
1210         }
1211
1212         /* create the items for the extent tree */
1213         memset(buf->data + sizeof(struct btrfs_header), 0,
1214                 cfg->nodesize - sizeof(struct btrfs_header));
1215         nritems = 0;
1216         itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
1217         for (i = 1; i < 7; i++) {
1218                 item_size = sizeof(struct btrfs_extent_item);
1219                 if (!skinny_metadata)
1220                         item_size += sizeof(struct btrfs_tree_block_info);
1221
1222                 if (cfg->blocks[i] < first_free) {
1223                         error("block[%d] below first free: %llu < %llu",
1224                                         i, (unsigned long long)cfg->blocks[i],
1225                                         (unsigned long long)first_free);
1226                         ret = -EINVAL;
1227                         goto out;
1228                 }
1229                 if (cfg->blocks[i] < cfg->blocks[i - 1]) {
1230                         error("blocks %d and %d in reverse order: %llu < %llu",
1231                                 i, i - 1,
1232                                 (unsigned long long)cfg->blocks[i],
1233                                 (unsigned long long)cfg->blocks[i - 1]);
1234                         ret = -EINVAL;
1235                         goto out;
1236                 }
1237
1238                 /* create extent item */
1239                 itemoff -= item_size;
1240                 btrfs_set_disk_key_objectid(&disk_key, cfg->blocks[i]);
1241                 if (skinny_metadata) {
1242                         btrfs_set_disk_key_type(&disk_key,
1243                                                 BTRFS_METADATA_ITEM_KEY);
1244                         btrfs_set_disk_key_offset(&disk_key, 0);
1245                 } else {
1246                         btrfs_set_disk_key_type(&disk_key,
1247                                                 BTRFS_EXTENT_ITEM_KEY);
1248                         btrfs_set_disk_key_offset(&disk_key, cfg->nodesize);
1249                 }
1250                 btrfs_set_item_key(buf, &disk_key, nritems);
1251                 btrfs_set_item_offset(buf, btrfs_item_nr(nritems),
1252                                       itemoff);
1253                 btrfs_set_item_size(buf, btrfs_item_nr(nritems),
1254                                     item_size);
1255                 extent_item = btrfs_item_ptr(buf, nritems,
1256                                              struct btrfs_extent_item);
1257                 btrfs_set_extent_refs(buf, extent_item, 1);
1258                 btrfs_set_extent_generation(buf, extent_item, 1);
1259                 btrfs_set_extent_flags(buf, extent_item,
1260                                        BTRFS_EXTENT_FLAG_TREE_BLOCK);
1261                 nritems++;
1262
1263                 /* create extent ref */
1264                 ref_root = reference_root_table[i];
1265                 btrfs_set_disk_key_objectid(&disk_key, cfg->blocks[i]);
1266                 btrfs_set_disk_key_offset(&disk_key, ref_root);
1267                 btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY);
1268                 btrfs_set_item_key(buf, &disk_key, nritems);
1269                 btrfs_set_item_offset(buf, btrfs_item_nr(nritems),
1270                                       itemoff);
1271                 btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0);
1272                 nritems++;
1273         }
1274         btrfs_set_header_bytenr(buf, cfg->blocks[2]);
1275         btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID);
1276         btrfs_set_header_nritems(buf, nritems);
1277         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1278         ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[2]);
1279         if (ret != cfg->nodesize) {
1280                 ret = (ret < 0 ? -errno : -EIO);
1281                 goto out;
1282         }
1283
1284         /* create the chunk tree */
1285         memset(buf->data + sizeof(struct btrfs_header), 0,
1286                 cfg->nodesize - sizeof(struct btrfs_header));
1287         nritems = 0;
1288         item_size = sizeof(*dev_item);
1289         itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - item_size;
1290
1291         /* first device 1 (there is no device 0) */
1292         btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
1293         btrfs_set_disk_key_offset(&disk_key, 1);
1294         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY);
1295         btrfs_set_item_key(buf, &disk_key, nritems);
1296         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1297         btrfs_set_item_size(buf, btrfs_item_nr(nritems), item_size);
1298
1299         dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item);
1300         btrfs_set_device_id(buf, dev_item, 1);
1301         btrfs_set_device_generation(buf, dev_item, 0);
1302         btrfs_set_device_total_bytes(buf, dev_item, num_bytes);
1303         btrfs_set_device_bytes_used(buf, dev_item,
1304                                     BTRFS_MKFS_SYSTEM_GROUP_SIZE);
1305         btrfs_set_device_io_align(buf, dev_item, cfg->sectorsize);
1306         btrfs_set_device_io_width(buf, dev_item, cfg->sectorsize);
1307         btrfs_set_device_sector_size(buf, dev_item, cfg->sectorsize);
1308         btrfs_set_device_type(buf, dev_item, 0);
1309
1310         write_extent_buffer(buf, super.dev_item.uuid,
1311                             (unsigned long)btrfs_device_uuid(dev_item),
1312                             BTRFS_UUID_SIZE);
1313         write_extent_buffer(buf, super.fsid,
1314                             (unsigned long)btrfs_device_fsid(dev_item),
1315                             BTRFS_UUID_SIZE);
1316         read_extent_buffer(buf, &super.dev_item, (unsigned long)dev_item,
1317                            sizeof(*dev_item));
1318
1319         nritems++;
1320         item_size = btrfs_chunk_item_size(1);
1321         itemoff = itemoff - item_size;
1322
1323         /* then we have chunk 0 */
1324         btrfs_set_disk_key_objectid(&disk_key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
1325         btrfs_set_disk_key_offset(&disk_key, 0);
1326         btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY);
1327         btrfs_set_item_key(buf, &disk_key, nritems);
1328         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1329         btrfs_set_item_size(buf, btrfs_item_nr(nritems), item_size);
1330
1331         chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk);
1332         btrfs_set_chunk_length(buf, chunk, BTRFS_MKFS_SYSTEM_GROUP_SIZE);
1333         btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID);
1334         btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024);
1335         btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM);
1336         btrfs_set_chunk_io_align(buf, chunk, cfg->sectorsize);
1337         btrfs_set_chunk_io_width(buf, chunk, cfg->sectorsize);
1338         btrfs_set_chunk_sector_size(buf, chunk, cfg->sectorsize);
1339         btrfs_set_chunk_num_stripes(buf, chunk, 1);
1340         btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
1341         btrfs_set_stripe_offset_nr(buf, chunk, 0, 0);
1342         nritems++;
1343
1344         write_extent_buffer(buf, super.dev_item.uuid,
1345                             (unsigned long)btrfs_stripe_dev_uuid(&chunk->stripe),
1346                             BTRFS_UUID_SIZE);
1347
1348         /* copy the key for the chunk to the system array */
1349         ptr = super.sys_chunk_array;
1350         array_size = sizeof(disk_key);
1351
1352         memcpy(ptr, &disk_key, sizeof(disk_key));
1353         ptr += sizeof(disk_key);
1354
1355         /* copy the chunk to the system array */
1356         read_extent_buffer(buf, ptr, (unsigned long)chunk, item_size);
1357         array_size += item_size;
1358         ptr += item_size;
1359         btrfs_set_super_sys_array_size(&super, array_size);
1360
1361         btrfs_set_header_bytenr(buf, cfg->blocks[3]);
1362         btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID);
1363         btrfs_set_header_nritems(buf, nritems);
1364         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1365         ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[3]);
1366         if (ret != cfg->nodesize) {
1367                 ret = (ret < 0 ? -errno : -EIO);
1368                 goto out;
1369         }
1370
1371         /* create the device tree */
1372         memset(buf->data + sizeof(struct btrfs_header), 0,
1373                 cfg->nodesize - sizeof(struct btrfs_header));
1374         nritems = 0;
1375         itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) -
1376                 sizeof(struct btrfs_dev_extent);
1377
1378         btrfs_set_disk_key_objectid(&disk_key, 1);
1379         btrfs_set_disk_key_offset(&disk_key, 0);
1380         btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY);
1381         btrfs_set_item_key(buf, &disk_key, nritems);
1382         btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
1383         btrfs_set_item_size(buf, btrfs_item_nr(nritems),
1384                             sizeof(struct btrfs_dev_extent));
1385         dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent);
1386         btrfs_set_dev_extent_chunk_tree(buf, dev_extent,
1387                                         BTRFS_CHUNK_TREE_OBJECTID);
1388         btrfs_set_dev_extent_chunk_objectid(buf, dev_extent,
1389                                         BTRFS_FIRST_CHUNK_TREE_OBJECTID);
1390         btrfs_set_dev_extent_chunk_offset(buf, dev_extent, 0);
1391
1392         write_extent_buffer(buf, chunk_tree_uuid,
1393                     (unsigned long)btrfs_dev_extent_chunk_tree_uuid(dev_extent),
1394                     BTRFS_UUID_SIZE);
1395
1396         btrfs_set_dev_extent_length(buf, dev_extent,
1397                                     BTRFS_MKFS_SYSTEM_GROUP_SIZE);
1398         nritems++;
1399
1400         btrfs_set_header_bytenr(buf, cfg->blocks[4]);
1401         btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID);
1402         btrfs_set_header_nritems(buf, nritems);
1403         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1404         ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[4]);
1405         if (ret != cfg->nodesize) {
1406                 ret = (ret < 0 ? -errno : -EIO);
1407                 goto out;
1408         }
1409
1410         /* create the FS root */
1411         memset(buf->data + sizeof(struct btrfs_header), 0,
1412                 cfg->nodesize - sizeof(struct btrfs_header));
1413         btrfs_set_header_bytenr(buf, cfg->blocks[5]);
1414         btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID);
1415         btrfs_set_header_nritems(buf, 0);
1416         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1417         ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[5]);
1418         if (ret != cfg->nodesize) {
1419                 ret = (ret < 0 ? -errno : -EIO);
1420                 goto out;
1421         }
1422         /* finally create the csum root */
1423         memset(buf->data + sizeof(struct btrfs_header), 0,
1424                 cfg->nodesize - sizeof(struct btrfs_header));
1425         btrfs_set_header_bytenr(buf, cfg->blocks[6]);
1426         btrfs_set_header_owner(buf, BTRFS_CSUM_TREE_OBJECTID);
1427         btrfs_set_header_nritems(buf, 0);
1428         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1429         ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[6]);
1430         if (ret != cfg->nodesize) {
1431                 ret = (ret < 0 ? -errno : -EIO);
1432                 goto out;
1433         }
1434
1435         /* and write out the super block */
1436         memset(buf->data, 0, BTRFS_SUPER_INFO_SIZE);
1437         memcpy(buf->data, &super, sizeof(super));
1438         buf->len = BTRFS_SUPER_INFO_SIZE;
1439         csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1440         ret = pwrite(fd, buf->data, BTRFS_SUPER_INFO_SIZE, cfg->blocks[0]);
1441         if (ret != BTRFS_SUPER_INFO_SIZE) {
1442                 ret = (ret < 0 ? -errno : -EIO);
1443                 goto out;
1444         }
1445
1446         ret = 0;
1447
1448 out:
1449         free(buf);
1450         return ret;
1451 }
1452
1453 static const struct btrfs_fs_feature {
1454         const char *name;
1455         u64 flag;
1456         const char *desc;
1457 } mkfs_features[] = {
1458         { "mixed-bg", BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS,
1459                 "mixed data and metadata block groups" },
1460         { "extref", BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF,
1461                 "increased hardlink limit per file to 65536" },
1462         { "raid56", BTRFS_FEATURE_INCOMPAT_RAID56,
1463                 "raid56 extended format" },
1464         { "skinny-metadata", BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA,
1465                 "reduced-size metadata extent refs" },
1466         { "no-holes", BTRFS_FEATURE_INCOMPAT_NO_HOLES,
1467                 "no explicit hole extents for files" },
1468         /* Keep this one last */
1469         { "list-all", BTRFS_FEATURE_LIST_ALL, NULL }
1470 };
1471
1472 static int parse_one_fs_feature(const char *name, u64 *flags)
1473 {
1474         int i;
1475         int found = 0;
1476
1477         for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
1478                 if (name[0] == '^' &&
1479                         !strcmp(mkfs_features[i].name, name + 1)) {
1480                         *flags &= ~ mkfs_features[i].flag;
1481                         found = 1;
1482                 } else if (!strcmp(mkfs_features[i].name, name)) {
1483                         *flags |= mkfs_features[i].flag;
1484                         found = 1;
1485                 }
1486         }
1487
1488         return !found;
1489 }
1490
1491 void btrfs_parse_features_to_string(char *buf, u64 flags)
1492 {
1493         int i;
1494
1495         buf[0] = 0;
1496
1497         for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
1498                 if (flags & mkfs_features[i].flag) {
1499                         if (*buf)
1500                                 strcat(buf, ", ");
1501                         strcat(buf, mkfs_features[i].name);
1502                 }
1503         }
1504 }
1505
1506 void btrfs_process_fs_features(u64 flags)
1507 {
1508         int i;
1509
1510         for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
1511                 if (flags & mkfs_features[i].flag) {
1512                         printf("Turning ON incompat feature '%s': %s\n",
1513                                 mkfs_features[i].name,
1514                                 mkfs_features[i].desc);
1515                 }
1516         }
1517 }
1518
1519 void btrfs_list_all_fs_features(u64 mask_disallowed)
1520 {
1521         int i;
1522
1523         fprintf(stderr, "Filesystem features available:\n");
1524         for (i = 0; i < ARRAY_SIZE(mkfs_features) - 1; i++) {
1525                 char *is_default = "";
1526
1527                 if (mkfs_features[i].flag & mask_disallowed)
1528                         continue;
1529                 if (mkfs_features[i].flag & BTRFS_MKFS_DEFAULT_FEATURES)
1530                         is_default = ", default";
1531                 fprintf(stderr, "%-20s- %s (0x%llx%s)\n",
1532                                 mkfs_features[i].name,
1533                                 mkfs_features[i].desc,
1534                                 mkfs_features[i].flag,
1535                                 is_default);
1536         }
1537 }
1538
1539 /*
1540  * Return NULL if all features were parsed fine, otherwise return the name of
1541  * the first unparsed.
1542  */
1543 char* btrfs_parse_fs_features(char *namelist, u64 *flags)
1544 {
1545         char *this_char;
1546         char *save_ptr = NULL; /* Satisfy static checkers */
1547
1548         for (this_char = strtok_r(namelist, ",", &save_ptr);
1549              this_char != NULL;
1550              this_char = strtok_r(NULL, ",", &save_ptr)) {
1551                 if (parse_one_fs_feature(this_char, flags))
1552                         return this_char;
1553         }
1554
1555         return NULL;
1556 }
1557
1558 u64 btrfs_device_size(int fd, struct stat *st)
1559 {
1560         u64 size;
1561         if (S_ISREG(st->st_mode)) {
1562                 return st->st_size;
1563         }
1564         if (!S_ISBLK(st->st_mode)) {
1565                 return 0;
1566         }
1567         if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
1568                 return size;
1569         }
1570         return 0;
1571 }
1572
1573 static int zero_blocks(int fd, off_t start, size_t len)
1574 {
1575         char *buf = malloc(len);
1576         int ret = 0;
1577         ssize_t written;
1578
1579         if (!buf)
1580                 return -ENOMEM;
1581         memset(buf, 0, len);
1582         written = pwrite(fd, buf, len, start);
1583         if (written != len)
1584                 ret = -EIO;
1585         free(buf);
1586         return ret;
1587 }
1588
1589 #define ZERO_DEV_BYTES (2 * 1024 * 1024)
1590
1591 /* don't write outside the device by clamping the region to the device size */
1592 static int zero_dev_clamped(int fd, off_t start, ssize_t len, u64 dev_size)
1593 {
1594         off_t end = max(start, start + len);
1595
1596 #ifdef __sparc__
1597         /* and don't overwrite the disk labels on sparc */
1598         start = max(start, 1024);
1599         end = max(end, 1024);
1600 #endif
1601
1602         start = min_t(u64, start, dev_size);
1603         end = min_t(u64, end, dev_size);
1604
1605         return zero_blocks(fd, start, end - start);
1606 }
1607
1608 int btrfs_add_to_fsid(struct btrfs_trans_handle *trans,
1609                       struct btrfs_root *root, int fd, char *path,
1610                       u64 device_total_bytes, u32 io_width, u32 io_align,
1611                       u32 sectorsize)
1612 {
1613         struct btrfs_super_block *disk_super;
1614         struct btrfs_super_block *super = root->fs_info->super_copy;
1615         struct btrfs_device *device;
1616         struct btrfs_dev_item *dev_item;
1617         char *buf = NULL;
1618         u64 fs_total_bytes;
1619         u64 num_devs;
1620         int ret;
1621
1622         device_total_bytes = (device_total_bytes / sectorsize) * sectorsize;
1623
1624         device = kzalloc(sizeof(*device), GFP_NOFS);
1625         if (!device)
1626                 goto err_nomem;
1627         buf = kzalloc(sectorsize, GFP_NOFS);
1628         if (!buf)
1629                 goto err_nomem;
1630
1631         disk_super = (struct btrfs_super_block *)buf;
1632         dev_item = &disk_super->dev_item;
1633
1634         uuid_generate(device->uuid);
1635         device->devid = 0;
1636         device->type = 0;
1637         device->io_width = io_width;
1638         device->io_align = io_align;
1639         device->sector_size = sectorsize;
1640         device->fd = fd;
1641         device->writeable = 1;
1642         device->total_bytes = device_total_bytes;
1643         device->bytes_used = 0;
1644         device->total_ios = 0;
1645         device->dev_root = root->fs_info->dev_root;
1646         device->name = strdup(path);
1647         if (!device->name)
1648                 goto err_nomem;
1649
1650         INIT_LIST_HEAD(&device->dev_list);
1651         ret = btrfs_add_device(trans, root, device);
1652         BUG_ON(ret);
1653
1654         fs_total_bytes = btrfs_super_total_bytes(super) + device_total_bytes;
1655         btrfs_set_super_total_bytes(super, fs_total_bytes);
1656
1657         num_devs = btrfs_super_num_devices(super) + 1;
1658         btrfs_set_super_num_devices(super, num_devs);
1659
1660         memcpy(disk_super, super, sizeof(*disk_super));
1661
1662         btrfs_set_super_bytenr(disk_super, BTRFS_SUPER_INFO_OFFSET);
1663         btrfs_set_stack_device_id(dev_item, device->devid);
1664         btrfs_set_stack_device_type(dev_item, device->type);
1665         btrfs_set_stack_device_io_align(dev_item, device->io_align);
1666         btrfs_set_stack_device_io_width(dev_item, device->io_width);
1667         btrfs_set_stack_device_sector_size(dev_item, device->sector_size);
1668         btrfs_set_stack_device_total_bytes(dev_item, device->total_bytes);
1669         btrfs_set_stack_device_bytes_used(dev_item, device->bytes_used);
1670         memcpy(&dev_item->uuid, device->uuid, BTRFS_UUID_SIZE);
1671
1672         ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
1673         BUG_ON(ret != sectorsize);
1674
1675         kfree(buf);
1676         list_add(&device->dev_list, &root->fs_info->fs_devices->devices);
1677         device->fs_devices = root->fs_info->fs_devices;
1678         return 0;
1679
1680 err_nomem:
1681         kfree(device);
1682         kfree(buf);
1683         return -ENOMEM;
1684 }
1685
1686 static int btrfs_wipe_existing_sb(int fd)
1687 {
1688         const char *off = NULL;
1689         size_t len = 0;
1690         loff_t offset;
1691         char buf[BUFSIZ];
1692         int ret = 0;
1693         blkid_probe pr = NULL;
1694
1695         pr = blkid_new_probe();
1696         if (!pr)
1697                 return -1;
1698
1699         if (blkid_probe_set_device(pr, fd, 0, 0)) {
1700                 ret = -1;
1701                 goto out;
1702         }
1703
1704         ret = blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL);
1705         if (!ret)
1706                 ret = blkid_probe_lookup_value(pr, "SBMAGIC", NULL, &len);
1707
1708         if (ret || len == 0 || off == NULL) {
1709                 /*
1710                  * If lookup fails, the probe did not find any values, eg. for
1711                  * a file image or a loop device. Soft error.
1712                  */
1713                 ret = 1;
1714                 goto out;
1715         }
1716
1717         offset = strtoll(off, NULL, 10);
1718         if (len > sizeof(buf))
1719                 len = sizeof(buf);
1720
1721         memset(buf, 0, len);
1722         ret = pwrite(fd, buf, len, offset);
1723         if (ret < 0) {
1724                 error("cannot wipe existing superblock: %s", strerror(errno));
1725                 ret = -1;
1726         } else if (ret != len) {
1727                 error("cannot wipe existing superblock: wrote %d of %zd", ret, len);
1728                 ret = -1;
1729         }
1730         fsync(fd);
1731
1732 out:
1733         blkid_free_probe(pr);
1734         return ret;
1735 }
1736
1737 int btrfs_prepare_device(int fd, const char *file, u64 *block_count_ret,
1738                 u64 max_block_count, unsigned opflags)
1739 {
1740         u64 block_count;
1741         struct stat st;
1742         int i, ret;
1743
1744         ret = fstat(fd, &st);
1745         if (ret < 0) {
1746                 error("unable to stat %s: %s", file, strerror(errno));
1747                 return 1;
1748         }
1749
1750         block_count = btrfs_device_size(fd, &st);
1751         if (block_count == 0) {
1752                 error("unable to determine size of %s", file);
1753                 return 1;
1754         }
1755         if (max_block_count)
1756                 block_count = min(block_count, max_block_count);
1757
1758         if (opflags & PREP_DEVICE_DISCARD) {
1759                 /*
1760                  * We intentionally ignore errors from the discard ioctl.  It
1761                  * is not necessary for the mkfs functionality but just an
1762                  * optimization.
1763                  */
1764                 if (discard_range(fd, 0, 0) == 0) {
1765                         if (opflags & PREP_DEVICE_VERBOSE)
1766                                 printf("Performing full device TRIM (%s) ...\n",
1767                                                 pretty_size(block_count));
1768                         discard_blocks(fd, 0, block_count);
1769                 }
1770         }
1771
1772         ret = zero_dev_clamped(fd, 0, ZERO_DEV_BYTES, block_count);
1773         for (i = 0 ; !ret && i < BTRFS_SUPER_MIRROR_MAX; i++)
1774                 ret = zero_dev_clamped(fd, btrfs_sb_offset(i),
1775                                        BTRFS_SUPER_INFO_SIZE, block_count);
1776         if (!ret && (opflags & PREP_DEVICE_ZERO_END))
1777                 ret = zero_dev_clamped(fd, block_count - ZERO_DEV_BYTES,
1778                                        ZERO_DEV_BYTES, block_count);
1779
1780         if (ret < 0) {
1781                 error("failed to zero device '%s': %s", file, strerror(-ret));
1782                 return 1;
1783         }
1784
1785         ret = btrfs_wipe_existing_sb(fd);
1786         if (ret < 0) {
1787                 error("cannot wipe superblocks on %s", file);
1788                 return 1;
1789         }
1790
1791         *block_count_ret = block_count;
1792         return 0;
1793 }
1794
1795 int btrfs_make_root_dir(struct btrfs_trans_handle *trans,
1796                         struct btrfs_root *root, u64 objectid)
1797 {
1798         int ret;
1799         struct btrfs_inode_item inode_item;
1800         time_t now = time(NULL);
1801
1802         memset(&inode_item, 0, sizeof(inode_item));
1803         btrfs_set_stack_inode_generation(&inode_item, trans->transid);
1804         btrfs_set_stack_inode_size(&inode_item, 0);
1805         btrfs_set_stack_inode_nlink(&inode_item, 1);
1806         btrfs_set_stack_inode_nbytes(&inode_item, root->nodesize);
1807         btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
1808         btrfs_set_stack_timespec_sec(&inode_item.atime, now);
1809         btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
1810         btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
1811         btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
1812         btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
1813         btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
1814         btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
1815         btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
1816
1817         if (root->fs_info->tree_root == root)
1818                 btrfs_set_super_root_dir(root->fs_info->super_copy, objectid);
1819
1820         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
1821         if (ret)
1822                 goto error;
1823
1824         ret = btrfs_insert_inode_ref(trans, root, "..", 2, objectid, objectid, 0);
1825         if (ret)
1826                 goto error;
1827
1828         btrfs_set_root_dirid(&root->root_item, objectid);
1829         ret = 0;
1830 error:
1831         return ret;
1832 }
1833
1834 /*
1835  * checks if a path is a block device node
1836  * Returns negative errno on failure, otherwise
1837  * returns 1 for blockdev, 0 for not-blockdev
1838  */
1839 int is_block_device(const char *path)
1840 {
1841         struct stat statbuf;
1842
1843         if (stat(path, &statbuf) < 0)
1844                 return -errno;
1845
1846         return !!S_ISBLK(statbuf.st_mode);
1847 }
1848
1849 /*
1850  * check if given path is a mount point
1851  * return 1 if yes. 0 if no. -1 for error
1852  */
1853 int is_mount_point(const char *path)
1854 {
1855         FILE *f;
1856         struct mntent *mnt;
1857         int ret = 0;
1858
1859         f = setmntent("/proc/self/mounts", "r");
1860         if (f == NULL)
1861                 return -1;
1862
1863         while ((mnt = getmntent(f)) != NULL) {
1864                 if (strcmp(mnt->mnt_dir, path))
1865                         continue;
1866                 ret = 1;
1867                 break;
1868         }
1869         endmntent(f);
1870         return ret;
1871 }
1872
1873 static int is_reg_file(const char *path)
1874 {
1875         struct stat statbuf;
1876
1877         if (stat(path, &statbuf) < 0)
1878                 return -errno;
1879         return S_ISREG(statbuf.st_mode);
1880 }
1881
1882 /*
1883  * This function checks if the given input parameter is
1884  * an uuid or a path
1885  * return <0 : some error in the given input
1886  * return BTRFS_ARG_UNKNOWN:    unknown input
1887  * return BTRFS_ARG_UUID:       given input is uuid
1888  * return BTRFS_ARG_MNTPOINT:   given input is path
1889  * return BTRFS_ARG_REG:        given input is regular file
1890  * return BTRFS_ARG_BLKDEV:     given input is block device
1891  */
1892 int check_arg_type(const char *input)
1893 {
1894         uuid_t uuid;
1895         char path[PATH_MAX];
1896
1897         if (!input)
1898                 return -EINVAL;
1899
1900         if (realpath(input, path)) {
1901                 if (is_block_device(path) == 1)
1902                         return BTRFS_ARG_BLKDEV;
1903
1904                 if (is_mount_point(path) == 1)
1905                         return BTRFS_ARG_MNTPOINT;
1906
1907                 if (is_reg_file(path))
1908                         return BTRFS_ARG_REG;
1909
1910                 return BTRFS_ARG_UNKNOWN;
1911         }
1912
1913         if (strlen(input) == (BTRFS_UUID_UNPARSED_SIZE - 1) &&
1914                 !uuid_parse(input, uuid))
1915                 return BTRFS_ARG_UUID;
1916
1917         return BTRFS_ARG_UNKNOWN;
1918 }
1919
1920 /*
1921  * Find the mount point for a mounted device.
1922  * On success, returns 0 with mountpoint in *mp.
1923  * On failure, returns -errno (not mounted yields -EINVAL)
1924  * Is noisy on failures, expects to be given a mounted device.
1925  */
1926 int get_btrfs_mount(const char *dev, char *mp, size_t mp_size)
1927 {
1928         int ret;
1929         int fd = -1;
1930
1931         ret = is_block_device(dev);
1932         if (ret <= 0) {
1933                 if (!ret) {
1934                         error("not a block device: %s", dev);
1935                         ret = -EINVAL;
1936                 } else {
1937                         error("cannot check %s: %s", dev, strerror(-ret));
1938                 }
1939                 goto out;
1940         }
1941
1942         fd = open(dev, O_RDONLY);
1943         if (fd < 0) {
1944                 ret = -errno;
1945                 error("cannot open %s: %s", dev, strerror(errno));
1946                 goto out;
1947         }
1948
1949         ret = check_mounted_where(fd, dev, mp, mp_size, NULL);
1950         if (!ret) {
1951                 ret = -EINVAL;
1952         } else { /* mounted, all good */
1953                 ret = 0;
1954         }
1955 out:
1956         if (fd != -1)
1957                 close(fd);
1958         return ret;
1959 }
1960
1961 /*
1962  * Given a pathname, return a filehandle to:
1963  *      the original pathname or,
1964  *      if the pathname is a mounted btrfs device, to its mountpoint.
1965  *
1966  * On error, return -1, errno should be set.
1967  */
1968 int open_path_or_dev_mnt(const char *path, DIR **dirstream, int verbose)
1969 {
1970         char mp[PATH_MAX];
1971         int ret;
1972
1973         if (is_block_device(path)) {
1974                 ret = get_btrfs_mount(path, mp, sizeof(mp));
1975                 if (ret < 0) {
1976                         /* not a mounted btrfs dev */
1977                         error_on(verbose, "'%s' is not a mounted btrfs device",
1978                                  path);
1979                         errno = EINVAL;
1980                         return -1;
1981                 }
1982                 ret = open_file_or_dir(mp, dirstream);
1983                 error_on(verbose && ret < 0, "can't access '%s': %s",
1984                          path, strerror(errno));
1985         } else {
1986                 ret = btrfs_open_dir(path, dirstream, 1);
1987         }
1988
1989         return ret;
1990 }
1991
1992 /*
1993  * Do the following checks before calling open_file_or_dir():
1994  * 1: path is in a btrfs filesystem
1995  * 2: path is a directory
1996  */
1997 int btrfs_open_dir(const char *path, DIR **dirstream, int verbose)
1998 {
1999         struct statfs stfs;
2000         struct stat st;
2001         int ret;
2002
2003         if (statfs(path, &stfs) != 0) {
2004                 error_on(verbose, "cannot access '%s': %s", path,
2005                                 strerror(errno));
2006                 return -1;
2007         }
2008
2009         if (stfs.f_type != BTRFS_SUPER_MAGIC) {
2010                 error_on(verbose, "not a btrfs filesystem: %s", path);
2011                 return -2;
2012         }
2013
2014         if (stat(path, &st) != 0) {
2015                 error_on(verbose, "cannot access '%s': %s", path,
2016                                 strerror(errno));
2017                 return -1;
2018         }
2019
2020         if (!S_ISDIR(st.st_mode)) {
2021                 error_on(verbose, "not a directory: %s", path);
2022                 return -3;
2023         }
2024
2025         ret = open_file_or_dir(path, dirstream);
2026         if (ret < 0) {
2027                 error_on(verbose, "cannot access '%s': %s", path,
2028                                 strerror(errno));
2029         }
2030
2031         return ret;
2032 }
2033
2034 /* checks if a device is a loop device */
2035 static int is_loop_device (const char* device) {
2036         struct stat statbuf;
2037
2038         if(stat(device, &statbuf) < 0)
2039                 return -errno;
2040
2041         return (S_ISBLK(statbuf.st_mode) &&
2042                 MAJOR(statbuf.st_rdev) == LOOP_MAJOR);
2043 }
2044
2045 /*
2046  * Takes a loop device path (e.g. /dev/loop0) and returns
2047  * the associated file (e.g. /images/my_btrfs.img) using
2048  * loopdev API
2049  */
2050 static int resolve_loop_device_with_loopdev(const char* loop_dev, char* loop_file)
2051 {
2052         int fd;
2053         int ret;
2054         struct loop_info64 lo64;
2055
2056         fd = open(loop_dev, O_RDONLY | O_NONBLOCK);
2057         if (fd < 0)
2058                 return -errno;
2059         ret = ioctl(fd, LOOP_GET_STATUS64, &lo64);
2060         if (ret < 0) {
2061                 ret = -errno;
2062                 goto out;
2063         }
2064
2065         memcpy(loop_file, lo64.lo_file_name, sizeof(lo64.lo_file_name));
2066         loop_file[sizeof(lo64.lo_file_name)] = 0;
2067
2068 out:
2069         close(fd);
2070
2071         return ret;
2072 }
2073
2074 /* Takes a loop device path (e.g. /dev/loop0) and returns
2075  * the associated file (e.g. /images/my_btrfs.img) */
2076 static int resolve_loop_device(const char* loop_dev, char* loop_file,
2077                 int max_len)
2078 {
2079         int ret;
2080         FILE *f;
2081         char fmt[20];
2082         char p[PATH_MAX];
2083         char real_loop_dev[PATH_MAX];
2084
2085         if (!realpath(loop_dev, real_loop_dev))
2086                 return -errno;
2087         snprintf(p, PATH_MAX, "/sys/block/%s/loop/backing_file", strrchr(real_loop_dev, '/'));
2088         if (!(f = fopen(p, "r"))) {
2089                 if (errno == ENOENT)
2090                         /*
2091                          * It's possibly a partitioned loop device, which is
2092                          * resolvable with loopdev API.
2093                          */
2094                         return resolve_loop_device_with_loopdev(loop_dev, loop_file);
2095                 return -errno;
2096         }
2097
2098         snprintf(fmt, 20, "%%%i[^\n]", max_len-1);
2099         ret = fscanf(f, fmt, loop_file);
2100         fclose(f);
2101         if (ret == EOF)
2102                 return -errno;
2103
2104         return 0;
2105 }
2106
2107 /*
2108  * Checks whether a and b are identical or device
2109  * files associated with the same block device
2110  */
2111 static int is_same_blk_file(const char* a, const char* b)
2112 {
2113         struct stat st_buf_a, st_buf_b;
2114         char real_a[PATH_MAX];
2115         char real_b[PATH_MAX];
2116
2117         if (!realpath(a, real_a))
2118                 strncpy_null(real_a, a);
2119
2120         if (!realpath(b, real_b))
2121                 strncpy_null(real_b, b);
2122
2123         /* Identical path? */
2124         if (strcmp(real_a, real_b) == 0)
2125                 return 1;
2126
2127         if (stat(a, &st_buf_a) < 0 || stat(b, &st_buf_b) < 0) {
2128                 if (errno == ENOENT)
2129                         return 0;
2130                 return -errno;
2131         }
2132
2133         /* Same blockdevice? */
2134         if (S_ISBLK(st_buf_a.st_mode) && S_ISBLK(st_buf_b.st_mode) &&
2135             st_buf_a.st_rdev == st_buf_b.st_rdev) {
2136                 return 1;
2137         }
2138
2139         /* Hardlink? */
2140         if (st_buf_a.st_dev == st_buf_b.st_dev &&
2141             st_buf_a.st_ino == st_buf_b.st_ino) {
2142                 return 1;
2143         }
2144
2145         return 0;
2146 }
2147
2148 /* checks if a and b are identical or device
2149  * files associated with the same block device or
2150  * if one file is a loop device that uses the other
2151  * file.
2152  */
2153 static int is_same_loop_file(const char* a, const char* b)
2154 {
2155         char res_a[PATH_MAX];
2156         char res_b[PATH_MAX];
2157         const char* final_a = NULL;
2158         const char* final_b = NULL;
2159         int ret;
2160
2161         /* Resolve a if it is a loop device */
2162         if((ret = is_loop_device(a)) < 0) {
2163                 if (ret == -ENOENT)
2164                         return 0;
2165                 return ret;
2166         } else if (ret) {
2167                 ret = resolve_loop_device(a, res_a, sizeof(res_a));
2168                 if (ret < 0) {
2169                         if (errno != EPERM)
2170                                 return ret;
2171                 } else {
2172                         final_a = res_a;
2173                 }
2174         } else {
2175                 final_a = a;
2176         }
2177
2178         /* Resolve b if it is a loop device */
2179         if ((ret = is_loop_device(b)) < 0) {
2180                 if (ret == -ENOENT)
2181                         return 0;
2182                 return ret;
2183         } else if (ret) {
2184                 ret = resolve_loop_device(b, res_b, sizeof(res_b));
2185                 if (ret < 0) {
2186                         if (errno != EPERM)
2187                                 return ret;
2188                 } else {
2189                         final_b = res_b;
2190                 }
2191         } else {
2192                 final_b = b;
2193         }
2194
2195         return is_same_blk_file(final_a, final_b);
2196 }
2197
2198 /* Checks if a file exists and is a block or regular file*/
2199 static int is_existing_blk_or_reg_file(const char* filename)
2200 {
2201         struct stat st_buf;
2202
2203         if(stat(filename, &st_buf) < 0) {
2204                 if(errno == ENOENT)
2205                         return 0;
2206                 else
2207                         return -errno;
2208         }
2209
2210         return (S_ISBLK(st_buf.st_mode) || S_ISREG(st_buf.st_mode));
2211 }
2212
2213 /* Checks if a file is used (directly or indirectly via a loop device)
2214  * by a device in fs_devices
2215  */
2216 static int blk_file_in_dev_list(struct btrfs_fs_devices* fs_devices,
2217                 const char* file)
2218 {
2219         int ret;
2220         struct list_head *head;
2221         struct list_head *cur;
2222         struct btrfs_device *device;
2223
2224         head = &fs_devices->devices;
2225         list_for_each(cur, head) {
2226                 device = list_entry(cur, struct btrfs_device, dev_list);
2227
2228                 if((ret = is_same_loop_file(device->name, file)))
2229                         return ret;
2230         }
2231
2232         return 0;
2233 }
2234
2235 /*
2236  * Resolve a pathname to a device mapper node to /dev/mapper/<name>
2237  * Returns NULL on invalid input or malloc failure; Other failures
2238  * will be handled by the caller using the input pathame.
2239  */
2240 char *canonicalize_dm_name(const char *ptname)
2241 {
2242         FILE    *f;
2243         size_t  sz;
2244         char    path[PATH_MAX], name[PATH_MAX], *res = NULL;
2245
2246         if (!ptname || !*ptname)
2247                 return NULL;
2248
2249         snprintf(path, sizeof(path), "/sys/block/%s/dm/name", ptname);
2250         if (!(f = fopen(path, "r")))
2251                 return NULL;
2252
2253         /* read <name>\n from sysfs */
2254         if (fgets(name, sizeof(name), f) && (sz = strlen(name)) > 1) {
2255                 name[sz - 1] = '\0';
2256                 snprintf(path, sizeof(path), "/dev/mapper/%s", name);
2257
2258                 if (access(path, F_OK) == 0)
2259                         res = strdup(path);
2260         }
2261         fclose(f);
2262         return res;
2263 }
2264
2265 /*
2266  * Resolve a pathname to a canonical device node, e.g. /dev/sda1 or
2267  * to a device mapper pathname.
2268  * Returns NULL on invalid input or malloc failure; Other failures
2269  * will be handled by the caller using the input pathame.
2270  */
2271 char *canonicalize_path(const char *path)
2272 {
2273         char *canonical, *p;
2274
2275         if (!path || !*path)
2276                 return NULL;
2277
2278         canonical = realpath(path, NULL);
2279         if (!canonical)
2280                 return strdup(path);
2281         p = strrchr(canonical, '/');
2282         if (p && strncmp(p, "/dm-", 4) == 0 && isdigit(*(p + 4))) {
2283                 char *dm = canonicalize_dm_name(p + 1);
2284
2285                 if (dm) {
2286                         free(canonical);
2287                         return dm;
2288                 }
2289         }
2290         return canonical;
2291 }
2292
2293 /*
2294  * returns 1 if the device was mounted, < 0 on error or 0 if everything
2295  * is safe to continue.
2296  */
2297 int check_mounted(const char* file)
2298 {
2299         int fd;
2300         int ret;
2301
2302         fd = open(file, O_RDONLY);
2303         if (fd < 0) {
2304                 error("mount check: cannot open %s: %s", file,
2305                                 strerror(errno));
2306                 return -errno;
2307         }
2308
2309         ret =  check_mounted_where(fd, file, NULL, 0, NULL);
2310         close(fd);
2311
2312         return ret;
2313 }
2314
2315 int check_mounted_where(int fd, const char *file, char *where, int size,
2316                         struct btrfs_fs_devices **fs_dev_ret)
2317 {
2318         int ret;
2319         u64 total_devs = 1;
2320         int is_btrfs;
2321         struct btrfs_fs_devices *fs_devices_mnt = NULL;
2322         FILE *f;
2323         struct mntent *mnt;
2324
2325         /* scan the initial device */
2326         ret = btrfs_scan_one_device(fd, file, &fs_devices_mnt,
2327                     &total_devs, BTRFS_SUPER_INFO_OFFSET, SBREAD_DEFAULT);
2328         is_btrfs = (ret >= 0);
2329
2330         /* scan other devices */
2331         if (is_btrfs && total_devs > 1) {
2332                 ret = btrfs_scan_lblkid();
2333                 if (ret)
2334                         return ret;
2335         }
2336
2337         /* iterate over the list of currently mounted filesystems */
2338         if ((f = setmntent ("/proc/self/mounts", "r")) == NULL)
2339                 return -errno;
2340
2341         while ((mnt = getmntent (f)) != NULL) {
2342                 if(is_btrfs) {
2343                         if(strcmp(mnt->mnt_type, "btrfs") != 0)
2344                                 continue;
2345
2346                         ret = blk_file_in_dev_list(fs_devices_mnt, mnt->mnt_fsname);
2347                 } else {
2348                         /* ignore entries in the mount table that are not
2349                            associated with a file*/
2350                         if((ret = is_existing_blk_or_reg_file(mnt->mnt_fsname)) < 0)
2351                                 goto out_mntloop_err;
2352                         else if(!ret)
2353                                 continue;
2354
2355                         ret = is_same_loop_file(file, mnt->mnt_fsname);
2356                 }
2357
2358                 if(ret < 0)
2359                         goto out_mntloop_err;
2360                 else if(ret)
2361                         break;
2362         }
2363
2364         /* Did we find an entry in mnt table? */
2365         if (mnt && size && where) {
2366                 strncpy(where, mnt->mnt_dir, size);
2367                 where[size-1] = 0;
2368         }
2369         if (fs_dev_ret)
2370                 *fs_dev_ret = fs_devices_mnt;
2371
2372         ret = (mnt != NULL);
2373
2374 out_mntloop_err:
2375         endmntent (f);
2376
2377         return ret;
2378 }
2379
2380 struct pending_dir {
2381         struct list_head list;
2382         char name[PATH_MAX];
2383 };
2384
2385 int btrfs_register_one_device(const char *fname)
2386 {
2387         struct btrfs_ioctl_vol_args args;
2388         int fd;
2389         int ret;
2390
2391         fd = open("/dev/btrfs-control", O_RDWR);
2392         if (fd < 0) {
2393                 warning(
2394         "failed to open /dev/btrfs-control, skipping device registration: %s",
2395                         strerror(errno));
2396                 return -errno;
2397         }
2398         memset(&args, 0, sizeof(args));
2399         strncpy_null(args.name, fname);
2400         ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args);
2401         if (ret < 0) {
2402                 error("device scan failed on '%s': %s", fname,
2403                                 strerror(errno));
2404                 ret = -errno;
2405         }
2406         close(fd);
2407         return ret;
2408 }
2409
2410 /*
2411  * Register all devices in the fs_uuid list created in the user
2412  * space. Ensure btrfs_scan_lblkid() is called before this func.
2413  */
2414 int btrfs_register_all_devices(void)
2415 {
2416         int err = 0;
2417         int ret = 0;
2418         struct btrfs_fs_devices *fs_devices;
2419         struct btrfs_device *device;
2420         struct list_head *all_uuids;
2421
2422         all_uuids = btrfs_scanned_uuids();
2423
2424         list_for_each_entry(fs_devices, all_uuids, list) {
2425                 list_for_each_entry(device, &fs_devices->devices, dev_list) {
2426                         if (*device->name)
2427                                 err = btrfs_register_one_device(device->name);
2428
2429                         if (err)
2430                                 ret++;
2431                 }
2432         }
2433
2434         return ret;
2435 }
2436
2437 int btrfs_device_already_in_root(struct btrfs_root *root, int fd,
2438                                  int super_offset)
2439 {
2440         struct btrfs_super_block *disk_super;
2441         char *buf;
2442         int ret = 0;
2443
2444         buf = malloc(BTRFS_SUPER_INFO_SIZE);
2445         if (!buf) {
2446                 ret = -ENOMEM;
2447                 goto out;
2448         }
2449         ret = pread(fd, buf, BTRFS_SUPER_INFO_SIZE, super_offset);
2450         if (ret != BTRFS_SUPER_INFO_SIZE)
2451                 goto brelse;
2452
2453         ret = 0;
2454         disk_super = (struct btrfs_super_block *)buf;
2455         /*
2456          * Accept devices from the same filesystem, allow partially created
2457          * structures.
2458          */
2459         if (btrfs_super_magic(disk_super) != BTRFS_MAGIC &&
2460                         btrfs_super_magic(disk_super) != BTRFS_MAGIC_PARTIAL)
2461                 goto brelse;
2462
2463         if (!memcmp(disk_super->fsid, root->fs_info->super_copy->fsid,
2464                     BTRFS_FSID_SIZE))
2465                 ret = 1;
2466 brelse:
2467         free(buf);
2468 out:
2469         return ret;
2470 }
2471
2472 /*
2473  * Note: this function uses a static per-thread buffer. Do not call this
2474  * function more than 10 times within one argument list!
2475  */
2476 const char *pretty_size_mode(u64 size, unsigned mode)
2477 {
2478         static __thread int ps_index = 0;
2479         static __thread char ps_array[10][32];
2480         char *ret;
2481
2482         ret = ps_array[ps_index];
2483         ps_index++;
2484         ps_index %= 10;
2485         (void)pretty_size_snprintf(size, ret, 32, mode);
2486
2487         return ret;
2488 }
2489
2490 static const char* unit_suffix_binary[] =
2491         { "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"};
2492 static const char* unit_suffix_decimal[] =
2493         { "B", "kB", "MB", "GB", "TB", "PB", "EB"};
2494
2495 int pretty_size_snprintf(u64 size, char *str, size_t str_size, unsigned unit_mode)
2496 {
2497         int num_divs;
2498         float fraction;
2499         u64 base = 0;
2500         int mult = 0;
2501         const char** suffix = NULL;
2502         u64 last_size;
2503
2504         if (str_size == 0)
2505                 return 0;
2506
2507         if ((unit_mode & ~UNITS_MODE_MASK) == UNITS_RAW) {
2508                 snprintf(str, str_size, "%llu", size);
2509                 return 0;
2510         }
2511
2512         if ((unit_mode & ~UNITS_MODE_MASK) == UNITS_BINARY) {
2513                 base = 1024;
2514                 mult = 1024;
2515                 suffix = unit_suffix_binary;
2516         } else if ((unit_mode & ~UNITS_MODE_MASK) == UNITS_DECIMAL) {
2517                 base = 1000;
2518                 mult = 1000;
2519                 suffix = unit_suffix_decimal;
2520         }
2521
2522         /* Unknown mode */
2523         if (!base) {
2524                 fprintf(stderr, "INTERNAL ERROR: unknown unit base, mode %d\n",
2525                                 unit_mode);
2526                 assert(0);
2527                 return -1;
2528         }
2529
2530         num_divs = 0;
2531         last_size = size;
2532         switch (unit_mode & UNITS_MODE_MASK) {
2533         case UNITS_TBYTES: base *= mult; num_divs++;
2534         case UNITS_GBYTES: base *= mult; num_divs++;
2535         case UNITS_MBYTES: base *= mult; num_divs++;
2536         case UNITS_KBYTES: num_divs++;
2537                            break;
2538         case UNITS_BYTES:
2539                            base = 1;
2540                            num_divs = 0;
2541                            break;
2542         default:
2543                 while (size >= mult) {
2544                         last_size = size;
2545                         size /= mult;
2546                         num_divs++;
2547                 }
2548                 /*
2549                  * If the value is smaller than base, we didn't do any
2550                  * division, in that case, base should be 1, not original
2551                  * base, or the unit will be wrong
2552                  */
2553                 if (num_divs == 0)
2554                         base = 1;
2555         }
2556
2557         if (num_divs >= ARRAY_SIZE(unit_suffix_binary)) {
2558                 str[0] = '\0';
2559                 printf("INTERNAL ERROR: unsupported unit suffix, index %d\n",
2560                                 num_divs);
2561                 assert(0);
2562                 return -1;
2563         }
2564         fraction = (float)last_size / base;
2565
2566         return snprintf(str, str_size, "%.2f%s", fraction, suffix[num_divs]);
2567 }
2568
2569 /*
2570  * __strncpy_null - strncpy with null termination
2571  * @dest:       the target array
2572  * @src:        the source string
2573  * @n:          maximum bytes to copy (size of *dest)
2574  *
2575  * Like strncpy, but ensures destination is null-terminated.
2576  *
2577  * Copies the string pointed to by src, including the terminating null
2578  * byte ('\0'), to the buffer pointed to by dest, up to a maximum
2579  * of n bytes.  Then ensure that dest is null-terminated.
2580  */
2581 char *__strncpy_null(char *dest, const char *src, size_t n)
2582 {
2583         strncpy(dest, src, n);
2584         if (n > 0)
2585                 dest[n - 1] = '\0';
2586         return dest;
2587 }
2588
2589 /*
2590  * Checks to make sure that the label matches our requirements.
2591  * Returns:
2592        0    if everything is safe and usable
2593       -1    if the label is too long
2594  */
2595 static int check_label(const char *input)
2596 {
2597        int len = strlen(input);
2598
2599        if (len > BTRFS_LABEL_SIZE - 1) {
2600                 error("label %s is too long (max %d)", input,
2601                                 BTRFS_LABEL_SIZE - 1);
2602                return -1;
2603        }
2604
2605        return 0;
2606 }
2607
2608 static int set_label_unmounted(const char *dev, const char *label)
2609 {
2610         struct btrfs_trans_handle *trans;
2611         struct btrfs_root *root;
2612         int ret;
2613
2614         ret = check_mounted(dev);
2615         if (ret < 0) {
2616                error("checking mount status of %s failed: %d", dev, ret);
2617                return -1;
2618         }
2619         if (ret > 0) {
2620                 error("device %s is mounted, use mount point", dev);
2621                 return -1;
2622         }
2623
2624         /* Open the super_block at the default location
2625          * and as read-write.
2626          */
2627         root = open_ctree(dev, 0, OPEN_CTREE_WRITES);
2628         if (!root) /* errors are printed by open_ctree() */
2629                 return -1;
2630
2631         trans = btrfs_start_transaction(root, 1);
2632         __strncpy_null(root->fs_info->super_copy->label, label, BTRFS_LABEL_SIZE - 1);
2633
2634         btrfs_commit_transaction(trans, root);
2635
2636         /* Now we close it since we are done. */
2637         close_ctree(root);
2638         return 0;
2639 }
2640
2641 static int set_label_mounted(const char *mount_path, const char *labelp)
2642 {
2643         int fd;
2644         char label[BTRFS_LABEL_SIZE];
2645
2646         fd = open(mount_path, O_RDONLY | O_NOATIME);
2647         if (fd < 0) {
2648                 error("unable to access %s: %s", mount_path, strerror(errno));
2649                 return -1;
2650         }
2651
2652         memset(label, 0, sizeof(label));
2653         __strncpy_null(label, labelp, BTRFS_LABEL_SIZE - 1);
2654         if (ioctl(fd, BTRFS_IOC_SET_FSLABEL, label) < 0) {
2655                 error("unable to set label of %s: %s", mount_path,
2656                                 strerror(errno));
2657                 close(fd);
2658                 return -1;
2659         }
2660
2661         close(fd);
2662         return 0;
2663 }
2664
2665 int get_label_unmounted(const char *dev, char *label)
2666 {
2667         struct btrfs_root *root;
2668         int ret;
2669
2670         ret = check_mounted(dev);
2671         if (ret < 0) {
2672                error("checking mount status of %s failed: %d", dev, ret);
2673                return -1;
2674         }
2675
2676         /* Open the super_block at the default location
2677          * and as read-only.
2678          */
2679         root = open_ctree(dev, 0, 0);
2680         if(!root)
2681                 return -1;
2682
2683         __strncpy_null(label, root->fs_info->super_copy->label,
2684                         BTRFS_LABEL_SIZE - 1);
2685
2686         /* Now we close it since we are done. */
2687         close_ctree(root);
2688         return 0;
2689 }
2690
2691 /*
2692  * If a partition is mounted, try to get the filesystem label via its
2693  * mounted path rather than device.  Return the corresponding error
2694  * the user specified the device path.
2695  */
2696 int get_label_mounted(const char *mount_path, char *labelp)
2697 {
2698         char label[BTRFS_LABEL_SIZE];
2699         int fd;
2700         int ret;
2701
2702         fd = open(mount_path, O_RDONLY | O_NOATIME);
2703         if (fd < 0) {
2704                 error("unable to access %s: %s", mount_path, strerror(errno));
2705                 return -1;
2706         }
2707
2708         memset(label, '\0', sizeof(label));
2709         ret = ioctl(fd, BTRFS_IOC_GET_FSLABEL, label);
2710         if (ret < 0) {
2711                 if (errno != ENOTTY)
2712                         error("unable to get label of %s: %s", mount_path,
2713                                         strerror(errno));
2714                 ret = -errno;
2715                 close(fd);
2716                 return ret;
2717         }
2718
2719         __strncpy_null(labelp, label, BTRFS_LABEL_SIZE - 1);
2720         close(fd);
2721         return 0;
2722 }
2723
2724 int get_label(const char *btrfs_dev, char *label)
2725 {
2726         int ret;
2727
2728         ret = is_existing_blk_or_reg_file(btrfs_dev);
2729         if (!ret)
2730                 ret = get_label_mounted(btrfs_dev, label);
2731         else if (ret > 0)
2732                 ret = get_label_unmounted(btrfs_dev, label);
2733
2734         return ret;
2735 }
2736
2737 int set_label(const char *btrfs_dev, const char *label)
2738 {
2739         int ret;
2740
2741         if (check_label(label))
2742                 return -1;
2743
2744         ret = is_existing_blk_or_reg_file(btrfs_dev);
2745         if (!ret)
2746                 ret = set_label_mounted(btrfs_dev, label);
2747         else if (ret > 0)
2748                 ret = set_label_unmounted(btrfs_dev, label);
2749
2750         return ret;
2751 }
2752
2753 /*
2754  * A not-so-good version fls64. No fascinating optimization since
2755  * no one except parse_size use it
2756  */
2757 static int fls64(u64 x)
2758 {
2759         int i;
2760
2761         for (i = 0; i <64; i++)
2762                 if (x << i & (1ULL << 63))
2763                         return 64 - i;
2764         return 64 - i;
2765 }
2766
2767 u64 parse_size(char *s)
2768 {
2769         char c;
2770         char *endptr;
2771         u64 mult = 1;
2772         u64 ret;
2773
2774         if (!s) {
2775                 error("size value is empty");
2776                 exit(1);
2777         }
2778         if (s[0] == '-') {
2779                 error("size value '%s' is less equal than 0", s);
2780                 exit(1);
2781         }
2782         ret = strtoull(s, &endptr, 10);
2783         if (endptr == s) {
2784                 error("size value '%s' is invalid", s);
2785                 exit(1);
2786         }
2787         if (endptr[0] && endptr[1]) {
2788                 error("illegal suffix contains character '%c' in wrong position",
2789                         endptr[1]);
2790                 exit(1);
2791         }
2792         /*
2793          * strtoll returns LLONG_MAX when overflow, if this happens,
2794          * need to call strtoull to get the real size
2795          */
2796         if (errno == ERANGE && ret == ULLONG_MAX) {
2797                 error("size value '%s' is too large for u64", s);
2798                 exit(1);
2799         }
2800         if (endptr[0]) {
2801                 c = tolower(endptr[0]);
2802                 switch (c) {
2803                 case 'e':
2804                         mult *= 1024;
2805                         /* fallthrough */
2806                 case 'p':
2807                         mult *= 1024;
2808                         /* fallthrough */
2809                 case 't':
2810                         mult *= 1024;
2811                         /* fallthrough */
2812                 case 'g':
2813                         mult *= 1024;
2814                         /* fallthrough */
2815                 case 'm':
2816                         mult *= 1024;
2817                         /* fallthrough */
2818                 case 'k':
2819                         mult *= 1024;
2820                         /* fallthrough */
2821                 case 'b':
2822                         break;
2823                 default:
2824                         error("unknown size descriptor '%c'", c);
2825                         exit(1);
2826                 }
2827         }
2828         /* Check whether ret * mult overflow */
2829         if (fls64(ret) + fls64(mult) - 1 > 64) {
2830                 error("size value '%s' is too large for u64", s);
2831                 exit(1);
2832         }
2833         ret *= mult;
2834         return ret;
2835 }
2836
2837 u64 parse_qgroupid(const char *p)
2838 {
2839         char *s = strchr(p, '/');
2840         const char *ptr_src_end = p + strlen(p);
2841         char *ptr_parse_end = NULL;
2842         u64 level;
2843         u64 id;
2844         int fd;
2845         int ret = 0;
2846
2847         if (p[0] == '/')
2848                 goto path;
2849
2850         /* Numeric format like '0/257' is the primary case */
2851         if (!s) {
2852                 id = strtoull(p, &ptr_parse_end, 10);
2853                 if (ptr_parse_end != ptr_src_end)
2854                         goto path;
2855                 return id;
2856         }
2857         level = strtoull(p, &ptr_parse_end, 10);
2858         if (ptr_parse_end != s)
2859                 goto path;
2860
2861         id = strtoull(s + 1, &ptr_parse_end, 10);
2862         if (ptr_parse_end != ptr_src_end)
2863                 goto  path;
2864
2865         return (level << BTRFS_QGROUP_LEVEL_SHIFT) | id;
2866
2867 path:
2868         /* Path format like subv at 'my_subvol' is the fallback case */
2869         ret = test_issubvolume(p);
2870         if (ret < 0 || !ret)
2871                 goto err;
2872         fd = open(p, O_RDONLY);
2873         if (fd < 0)
2874                 goto err;
2875         ret = lookup_ino_rootid(fd, &id);
2876         if (ret)
2877                 error("failed to lookup root id: %s", strerror(-ret));
2878         close(fd);
2879         if (ret < 0)
2880                 goto err;
2881         return id;
2882
2883 err:
2884         error("invalid qgroupid or subvolume path: %s", p);
2885         exit(-1);
2886 }
2887
2888 int open_file_or_dir3(const char *fname, DIR **dirstream, int open_flags)
2889 {
2890         int ret;
2891         struct stat st;
2892         int fd;
2893
2894         ret = stat(fname, &st);
2895         if (ret < 0) {
2896                 return -1;
2897         }
2898         if (S_ISDIR(st.st_mode)) {
2899                 *dirstream = opendir(fname);
2900                 if (!*dirstream)
2901                         return -1;
2902                 fd = dirfd(*dirstream);
2903         } else if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
2904                 fd = open(fname, open_flags);
2905         } else {
2906                 /*
2907                  * we set this on purpose, in case the caller output
2908                  * strerror(errno) as success
2909                  */
2910                 errno = EINVAL;
2911                 return -1;
2912         }
2913         if (fd < 0) {
2914                 fd = -1;
2915                 if (*dirstream) {
2916                         closedir(*dirstream);
2917                         *dirstream = NULL;
2918                 }
2919         }
2920         return fd;
2921 }
2922
2923 int open_file_or_dir(const char *fname, DIR **dirstream)
2924 {
2925         return open_file_or_dir3(fname, dirstream, O_RDWR);
2926 }
2927
2928 void close_file_or_dir(int fd, DIR *dirstream)
2929 {
2930         if (dirstream)
2931                 closedir(dirstream);
2932         else if (fd >= 0)
2933                 close(fd);
2934 }
2935
2936 int get_device_info(int fd, u64 devid,
2937                 struct btrfs_ioctl_dev_info_args *di_args)
2938 {
2939         int ret;
2940
2941         di_args->devid = devid;
2942         memset(&di_args->uuid, '\0', sizeof(di_args->uuid));
2943
2944         ret = ioctl(fd, BTRFS_IOC_DEV_INFO, di_args);
2945         return ret < 0 ? -errno : 0;
2946 }
2947
2948 static u64 find_max_device_id(struct btrfs_ioctl_search_args *search_args,
2949                               int nr_items)
2950 {
2951         struct btrfs_dev_item *dev_item;
2952         char *buf = search_args->buf;
2953
2954         buf += (nr_items - 1) * (sizeof(struct btrfs_ioctl_search_header)
2955                                        + sizeof(struct btrfs_dev_item));
2956         buf += sizeof(struct btrfs_ioctl_search_header);
2957
2958         dev_item = (struct btrfs_dev_item *)buf;
2959
2960         return btrfs_stack_device_id(dev_item);
2961 }
2962
2963 static int search_chunk_tree_for_fs_info(int fd,
2964                                 struct btrfs_ioctl_fs_info_args *fi_args)
2965 {
2966         int ret;
2967         int max_items;
2968         u64 start_devid = 1;
2969         struct btrfs_ioctl_search_args search_args;
2970         struct btrfs_ioctl_search_key *search_key = &search_args.key;
2971
2972         fi_args->num_devices = 0;
2973
2974         max_items = BTRFS_SEARCH_ARGS_BUFSIZE
2975                / (sizeof(struct btrfs_ioctl_search_header)
2976                                + sizeof(struct btrfs_dev_item));
2977
2978         search_key->tree_id = BTRFS_CHUNK_TREE_OBJECTID;
2979         search_key->min_objectid = BTRFS_DEV_ITEMS_OBJECTID;
2980         search_key->max_objectid = BTRFS_DEV_ITEMS_OBJECTID;
2981         search_key->min_type = BTRFS_DEV_ITEM_KEY;
2982         search_key->max_type = BTRFS_DEV_ITEM_KEY;
2983         search_key->min_transid = 0;
2984         search_key->max_transid = (u64)-1;
2985         search_key->nr_items = max_items;
2986         search_key->max_offset = (u64)-1;
2987
2988 again:
2989         search_key->min_offset = start_devid;
2990
2991         ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search_args);
2992         if (ret < 0)
2993                 return -errno;
2994
2995         fi_args->num_devices += (u64)search_key->nr_items;
2996
2997         if (search_key->nr_items == max_items) {
2998                 start_devid = find_max_device_id(&search_args,
2999                                         search_key->nr_items) + 1;
3000                 goto again;
3001         }
3002
3003         /* get the lastest max_id to stay consistent with the num_devices */
3004         if (search_key->nr_items == 0)
3005                 /*
3006                  * last tree_search returns an empty buf, use the devid of
3007                  * the last dev_item of the previous tree_search
3008                  */
3009                 fi_args->max_id = start_devid - 1;
3010         else
3011                 fi_args->max_id = find_max_device_id(&search_args,
3012                                                 search_key->nr_items);
3013
3014         return 0;
3015 }
3016
3017 /*
3018  * For a given path, fill in the ioctl fs_ and info_ args.
3019  * If the path is a btrfs mountpoint, fill info for all devices.
3020  * If the path is a btrfs device, fill in only that device.
3021  *
3022  * The path provided must be either on a mounted btrfs fs,
3023  * or be a mounted btrfs device.
3024  *
3025  * Returns 0 on success, or a negative errno.
3026  */
3027 int get_fs_info(char *path, struct btrfs_ioctl_fs_info_args *fi_args,
3028                 struct btrfs_ioctl_dev_info_args **di_ret)
3029 {
3030         int fd = -1;
3031         int ret = 0;
3032         int ndevs = 0;
3033         int i = 0;
3034         int replacing = 0;
3035         struct btrfs_fs_devices *fs_devices_mnt = NULL;
3036         struct btrfs_ioctl_dev_info_args *di_args;
3037         struct btrfs_ioctl_dev_info_args tmp;
3038         char mp[PATH_MAX];
3039         DIR *dirstream = NULL;
3040
3041         memset(fi_args, 0, sizeof(*fi_args));
3042
3043         if (is_block_device(path) == 1) {
3044                 struct btrfs_super_block *disk_super;
3045                 char buf[BTRFS_SUPER_INFO_SIZE];
3046                 u64 devid;
3047
3048                 /* Ensure it's mounted, then set path to the mountpoint */
3049                 fd = open(path, O_RDONLY);
3050                 if (fd < 0) {
3051                         ret = -errno;
3052                         error("cannot open %s: %s", path, strerror(errno));
3053                         goto out;
3054                 }
3055                 ret = check_mounted_where(fd, path, mp, sizeof(mp),
3056                                           &fs_devices_mnt);
3057                 if (!ret) {
3058                         ret = -EINVAL;
3059                         goto out;
3060                 }
3061                 if (ret < 0)
3062                         goto out;
3063                 path = mp;
3064                 /* Only fill in this one device */
3065                 fi_args->num_devices = 1;
3066
3067                 disk_super = (struct btrfs_super_block *)buf;
3068                 ret = btrfs_read_dev_super(fd, disk_super,
3069                                            BTRFS_SUPER_INFO_OFFSET, 0);
3070                 if (ret < 0) {
3071                         ret = -EIO;
3072                         goto out;
3073                 }
3074                 devid = btrfs_stack_device_id(&disk_super->dev_item);
3075
3076                 fi_args->max_id = devid;
3077                 i = devid;
3078
3079                 memcpy(fi_args->fsid, fs_devices_mnt->fsid, BTRFS_FSID_SIZE);
3080                 close(fd);
3081         }
3082
3083         /* at this point path must not be for a block device */
3084         fd = open_file_or_dir(path, &dirstream);
3085         if (fd < 0) {
3086                 ret = -errno;
3087                 goto out;
3088         }
3089
3090         /* fill in fi_args if not just a single device */
3091         if (fi_args->num_devices != 1) {
3092                 ret = ioctl(fd, BTRFS_IOC_FS_INFO, fi_args);
3093                 if (ret < 0) {
3094                         ret = -errno;
3095                         goto out;
3096                 }
3097
3098                 /*
3099                  * The fs_args->num_devices does not include seed devices
3100                  */
3101                 ret = search_chunk_tree_for_fs_info(fd, fi_args);
3102                 if (ret)
3103                         goto out;
3104
3105                 /*
3106                  * search_chunk_tree_for_fs_info() will lacks the devid 0
3107                  * so manual probe for it here.
3108                  */
3109                 ret = get_device_info(fd, 0, &tmp);
3110                 if (!ret) {
3111                         fi_args->num_devices++;
3112                         ndevs++;
3113                         replacing = 1;
3114                         if (i == 0)
3115                                 i++;
3116                 }
3117         }
3118
3119         if (!fi_args->num_devices)
3120                 goto out;
3121
3122         di_args = *di_ret = malloc((fi_args->num_devices) * sizeof(*di_args));
3123         if (!di_args) {
3124                 ret = -errno;
3125                 goto out;
3126         }
3127
3128         if (replacing)
3129                 memcpy(di_args, &tmp, sizeof(tmp));
3130         for (; i <= fi_args->max_id; ++i) {
3131                 ret = get_device_info(fd, i, &di_args[ndevs]);
3132                 if (ret == -ENODEV)
3133                         continue;
3134                 if (ret)
3135                         goto out;
3136                 ndevs++;
3137         }
3138
3139         /*
3140         * only when the only dev we wanted to find is not there then
3141         * let any error be returned
3142         */
3143         if (fi_args->num_devices != 1) {
3144                 BUG_ON(ndevs == 0);
3145                 ret = 0;
3146         }
3147
3148 out:
3149         close_file_or_dir(fd, dirstream);
3150         return ret;
3151 }
3152
3153 #define isoctal(c)      (((c) & ~7) == '0')
3154
3155 static inline void translate(char *f, char *t)
3156 {
3157         while (*f != '\0') {
3158                 if (*f == '\\' &&
3159                     isoctal(f[1]) && isoctal(f[2]) && isoctal(f[3])) {
3160                         *t++ = 64*(f[1] & 7) + 8*(f[2] & 7) + (f[3] & 7);
3161                         f += 4;
3162                 } else
3163                         *t++ = *f++;
3164         }
3165         *t = '\0';
3166         return;
3167 }
3168
3169 /*
3170  * Checks if the swap device.
3171  * Returns 1 if swap device, < 0 on error or 0 if not swap device.
3172  */
3173 static int is_swap_device(const char *file)
3174 {
3175         FILE    *f;
3176         struct stat     st_buf;
3177         dev_t   dev;
3178         ino_t   ino = 0;
3179         char    tmp[PATH_MAX];
3180         char    buf[PATH_MAX];
3181         char    *cp;
3182         int     ret = 0;
3183
3184         if (stat(file, &st_buf) < 0)
3185                 return -errno;
3186         if (S_ISBLK(st_buf.st_mode))
3187                 dev = st_buf.st_rdev;
3188         else if (S_ISREG(st_buf.st_mode)) {
3189                 dev = st_buf.st_dev;
3190                 ino = st_buf.st_ino;
3191         } else
3192                 return 0;
3193
3194         if ((f = fopen("/proc/swaps", "r")) == NULL)
3195                 return 0;
3196
3197         /* skip the first line */
3198         if (fgets(tmp, sizeof(tmp), f) == NULL)
3199                 goto out;
3200
3201         while (fgets(tmp, sizeof(tmp), f) != NULL) {
3202                 if ((cp = strchr(tmp, ' ')) != NULL)
3203                         *cp = '\0';
3204                 if ((cp = strchr(tmp, '\t')) != NULL)
3205                         *cp = '\0';
3206                 translate(tmp, buf);
3207                 if (stat(buf, &st_buf) != 0)
3208                         continue;
3209                 if (S_ISBLK(st_buf.st_mode)) {
3210                         if (dev == st_buf.st_rdev) {
3211                                 ret = 1;
3212                                 break;
3213                         }
3214                 } else if (S_ISREG(st_buf.st_mode)) {
3215                         if (dev == st_buf.st_dev && ino == st_buf.st_ino) {
3216                                 ret = 1;
3217                                 break;
3218                         }
3219                 }
3220         }
3221
3222 out:
3223         fclose(f);
3224
3225         return ret;
3226 }
3227
3228 /*
3229  * Check for existing filesystem or partition table on device.
3230  * Returns:
3231  *       1 for existing fs or partition
3232  *       0 for nothing found
3233  *      -1 for internal error
3234  */
3235 static int check_overwrite(const char *device)
3236 {
3237         const char      *type;
3238         blkid_probe     pr = NULL;
3239         int             ret;
3240         blkid_loff_t    size;
3241
3242         if (!device || !*device)
3243                 return 0;
3244
3245         ret = -1; /* will reset on success of all setup calls */
3246
3247         pr = blkid_new_probe_from_filename(device);
3248         if (!pr)
3249                 goto out;
3250
3251         size = blkid_probe_get_size(pr);
3252         if (size < 0)
3253                 goto out;
3254
3255         /* nothing to overwrite on a 0-length device */
3256         if (size == 0) {
3257                 ret = 0;
3258                 goto out;
3259         }
3260
3261         ret = blkid_probe_enable_partitions(pr, 1);
3262         if (ret < 0)
3263                 goto out;
3264
3265         ret = blkid_do_fullprobe(pr);
3266         if (ret < 0)
3267                 goto out;
3268
3269         /*
3270          * Blkid returns 1 for nothing found and 0 when it finds a signature,
3271          * but we want the exact opposite, so reverse the return value here.
3272          *
3273          * In addition print some useful diagnostics about what actually is
3274          * on the device.
3275          */
3276         if (ret) {
3277                 ret = 0;
3278                 goto out;
3279         }
3280
3281         if (!blkid_probe_lookup_value(pr, "TYPE", &type, NULL)) {
3282                 fprintf(stderr,
3283                         "%s appears to contain an existing "
3284                         "filesystem (%s).\n", device, type);
3285         } else if (!blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL)) {
3286                 fprintf(stderr,
3287                         "%s appears to contain a partition "
3288                         "table (%s).\n", device, type);
3289         } else {
3290                 fprintf(stderr,
3291                         "%s appears to contain something weird "
3292                         "according to blkid\n", device);
3293         }
3294         ret = 1;
3295
3296 out:
3297         if (pr)
3298                 blkid_free_probe(pr);
3299         if (ret == -1)
3300                 fprintf(stderr,
3301                         "probe of %s failed, cannot detect "
3302                           "existing filesystem.\n", device);
3303         return ret;
3304 }
3305
3306 static int group_profile_devs_min(u64 flag)
3307 {
3308         switch (flag & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
3309         case 0: /* single */
3310         case BTRFS_BLOCK_GROUP_DUP:
3311                 return 1;
3312         case BTRFS_BLOCK_GROUP_RAID0:
3313         case BTRFS_BLOCK_GROUP_RAID1:
3314         case BTRFS_BLOCK_GROUP_RAID5:
3315                 return 2;
3316         case BTRFS_BLOCK_GROUP_RAID6:
3317                 return 3;
3318         case BTRFS_BLOCK_GROUP_RAID10:
3319                 return 4;
3320         default:
3321                 return -1;
3322         }
3323 }
3324
3325 int test_num_disk_vs_raid(u64 metadata_profile, u64 data_profile,
3326         u64 dev_cnt, int mixed, int ssd)
3327 {
3328         u64 allowed = 0;
3329         u64 profile = metadata_profile | data_profile;
3330
3331         switch (dev_cnt) {
3332         default:
3333         case 4:
3334                 allowed |= BTRFS_BLOCK_GROUP_RAID10;
3335         case 3:
3336                 allowed |= BTRFS_BLOCK_GROUP_RAID6;
3337         case 2:
3338                 allowed |= BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1 |
3339                         BTRFS_BLOCK_GROUP_RAID5;
3340         case 1:
3341                 allowed |= BTRFS_BLOCK_GROUP_DUP;
3342         }
3343
3344         if (dev_cnt > 1 && profile & BTRFS_BLOCK_GROUP_DUP) {
3345                 warning("DUP is not recommended on filesystem with multiple devices");
3346         }
3347         if (metadata_profile & ~allowed) {
3348                 fprintf(stderr,
3349                         "ERROR: unable to create FS with metadata profile %s "
3350                         "(have %llu devices but %d devices are required)\n",
3351                         btrfs_group_profile_str(metadata_profile), dev_cnt,
3352                         group_profile_devs_min(metadata_profile));
3353                 return 1;
3354         }
3355         if (data_profile & ~allowed) {
3356                 fprintf(stderr,
3357                         "ERROR: unable to create FS with data profile %s "
3358                         "(have %llu devices but %d devices are required)\n",
3359                         btrfs_group_profile_str(data_profile), dev_cnt,
3360                         group_profile_devs_min(data_profile));
3361                 return 1;
3362         }
3363
3364         if (dev_cnt == 3 && profile & BTRFS_BLOCK_GROUP_RAID6) {
3365                 warning("RAID6 is not recommended on filesystem with 3 devices only");
3366         }
3367         if (dev_cnt == 2 && profile & BTRFS_BLOCK_GROUP_RAID5) {
3368                 warning("RAID5 is not recommended on filesystem with 2 devices only");
3369         }
3370         warning_on(!mixed && (data_profile & BTRFS_BLOCK_GROUP_DUP) && ssd,
3371                    "DUP may not actually lead to 2 copies on the device, see manual page");
3372
3373         return 0;
3374 }
3375
3376 int group_profile_max_safe_loss(u64 flags)
3377 {
3378         switch (flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
3379         case 0: /* single */
3380         case BTRFS_BLOCK_GROUP_DUP:
3381         case BTRFS_BLOCK_GROUP_RAID0:
3382                 return 0;
3383         case BTRFS_BLOCK_GROUP_RAID1:
3384         case BTRFS_BLOCK_GROUP_RAID5:
3385         case BTRFS_BLOCK_GROUP_RAID10:
3386                 return 1;
3387         case BTRFS_BLOCK_GROUP_RAID6:
3388                 return 2;
3389         default:
3390                 return -1;
3391         }
3392 }
3393
3394 /*
3395  * Check if a device is suitable for btrfs
3396  * returns:
3397  *  1: something is wrong, an error is printed
3398  *  0: all is fine
3399  */
3400 int test_dev_for_mkfs(const char *file, int force_overwrite)
3401 {
3402         int ret, fd;
3403         struct stat st;
3404
3405         ret = is_swap_device(file);
3406         if (ret < 0) {
3407                 error("checking status of %s: %s", file, strerror(-ret));
3408                 return 1;
3409         }
3410         if (ret == 1) {
3411                 error("%s is a swap device", file);
3412                 return 1;
3413         }
3414         if (!force_overwrite) {
3415                 if (check_overwrite(file)) {
3416                         error("use the -f option to force overwrite of %s",
3417                                         file);
3418                         return 1;
3419                 }
3420         }
3421         ret = check_mounted(file);
3422         if (ret < 0) {
3423                 error("cannot check mount status of %s: %s", file,
3424                                 strerror(-ret));
3425                 return 1;
3426         }
3427         if (ret == 1) {
3428                 error("%s is mounted", file);
3429                 return 1;
3430         }
3431         /* check if the device is busy */
3432         fd = open(file, O_RDWR|O_EXCL);
3433         if (fd < 0) {
3434                 error("unable to open %s: %s", file, strerror(errno));
3435                 return 1;
3436         }
3437         if (fstat(fd, &st)) {
3438                 error("unable to stat %s: %s", file, strerror(errno));
3439                 close(fd);
3440                 return 1;
3441         }
3442         if (!S_ISBLK(st.st_mode)) {
3443                 error("%s is not a block device", file);
3444                 close(fd);
3445                 return 1;
3446         }
3447         close(fd);
3448         return 0;
3449 }
3450
3451 int btrfs_scan_lblkid(void)
3452 {
3453         int fd = -1;
3454         int ret;
3455         u64 num_devices;
3456         struct btrfs_fs_devices *tmp_devices;
3457         blkid_dev_iterate iter = NULL;
3458         blkid_dev dev = NULL;
3459         blkid_cache cache = NULL;
3460         char path[PATH_MAX];
3461
3462         if (btrfs_scan_done)
3463                 return 0;
3464
3465         if (blkid_get_cache(&cache, NULL) < 0) {
3466                 error("blkid cache get failed");
3467                 return 1;
3468         }
3469         blkid_probe_all(cache);
3470         iter = blkid_dev_iterate_begin(cache);
3471         blkid_dev_set_search(iter, "TYPE", "btrfs");
3472         while (blkid_dev_next(iter, &dev) == 0) {
3473                 dev = blkid_verify(cache, dev);
3474                 if (!dev)
3475                         continue;
3476                 /* if we are here its definitely a btrfs disk*/
3477                 strncpy_null(path, blkid_dev_devname(dev));
3478
3479                 fd = open(path, O_RDONLY);
3480                 if (fd < 0) {
3481                         error("cannot open %s: %s", path, strerror(errno));
3482                         continue;
3483                 }
3484                 ret = btrfs_scan_one_device(fd, path, &tmp_devices,
3485                                 &num_devices, BTRFS_SUPER_INFO_OFFSET,
3486                                 SBREAD_DEFAULT);
3487                 if (ret) {
3488                         error("cannot scan %s: %s", path, strerror(-ret));
3489                         close (fd);
3490                         continue;
3491                 }
3492
3493                 close(fd);
3494         }
3495         blkid_dev_iterate_end(iter);
3496         blkid_put_cache(cache);
3497
3498         btrfs_scan_done = 1;
3499
3500         return 0;
3501 }
3502
3503 int is_vol_small(const char *file)
3504 {
3505         int fd = -1;
3506         int e;
3507         struct stat st;
3508         u64 size;
3509
3510         fd = open(file, O_RDONLY);
3511         if (fd < 0)
3512                 return -errno;
3513         if (fstat(fd, &st) < 0) {
3514                 e = -errno;
3515                 close(fd);
3516                 return e;
3517         }
3518         size = btrfs_device_size(fd, &st);
3519         if (size == 0) {
3520                 close(fd);
3521                 return -1;
3522         }
3523         if (size < BTRFS_MKFS_SMALL_VOLUME_SIZE) {
3524                 close(fd);
3525                 return 1;
3526         } else {
3527                 close(fd);
3528                 return 0;
3529         }
3530 }
3531
3532 /*
3533  * This reads a line from the stdin and only returns non-zero if the
3534  * first whitespace delimited token is a case insensitive match with yes
3535  * or y.
3536  */
3537 int ask_user(const char *question)
3538 {
3539         char buf[30] = {0,};
3540         char *saveptr = NULL;
3541         char *answer;
3542
3543         printf("%s [y/N]: ", question);
3544
3545         return fgets(buf, sizeof(buf) - 1, stdin) &&
3546                (answer = strtok_r(buf, " \t\n\r", &saveptr)) &&
3547                (!strcasecmp(answer, "yes") || !strcasecmp(answer, "y"));
3548 }
3549
3550 /*
3551  * For a given:
3552  * - file or directory return the containing tree root id
3553  * - subvolume return its own tree id
3554  * - BTRFS_EMPTY_SUBVOL_DIR_OBJECTID (directory with ino == 2) the result is
3555  *   undefined and function returns -1
3556  */
3557 int lookup_ino_rootid(int fd, u64 *rootid)
3558 {
3559         struct btrfs_ioctl_ino_lookup_args args;
3560         int ret;
3561
3562         memset(&args, 0, sizeof(args));
3563         args.treeid = 0;
3564         args.objectid = BTRFS_FIRST_FREE_OBJECTID;
3565
3566         ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
3567         if (ret < 0)
3568                 return -errno;
3569
3570         *rootid = args.treeid;
3571
3572         return 0;
3573 }
3574
3575 /*
3576  * return 0 if a btrfs mount point is found
3577  * return 1 if a mount point is found but not btrfs
3578  * return <0 if something goes wrong
3579  */
3580 int find_mount_root(const char *path, char **mount_root)
3581 {
3582         FILE *mnttab;
3583         int fd;
3584         struct mntent *ent;
3585         int len;
3586         int ret;
3587         int not_btrfs = 1;
3588         int longest_matchlen = 0;
3589         char *longest_match = NULL;
3590
3591         fd = open(path, O_RDONLY | O_NOATIME);
3592         if (fd < 0)
3593                 return -errno;
3594         close(fd);
3595
3596         mnttab = setmntent("/proc/self/mounts", "r");
3597         if (!mnttab)
3598                 return -errno;
3599
3600         while ((ent = getmntent(mnttab))) {
3601                 len = strlen(ent->mnt_dir);
3602                 if (strncmp(ent->mnt_dir, path, len) == 0) {
3603                         /* match found and use the latest match */
3604                         if (longest_matchlen <= len) {
3605                                 free(longest_match);
3606                                 longest_matchlen = len;
3607                                 longest_match = strdup(ent->mnt_dir);
3608                                 not_btrfs = strcmp(ent->mnt_type, "btrfs");
3609                         }
3610                 }
3611         }
3612         endmntent(mnttab);
3613
3614         if (!longest_match)
3615                 return -ENOENT;
3616         if (not_btrfs) {
3617                 free(longest_match);
3618                 return 1;
3619         }
3620
3621         ret = 0;
3622         *mount_root = realpath(longest_match, NULL);
3623         if (!*mount_root)
3624                 ret = -errno;
3625
3626         free(longest_match);
3627         return ret;
3628 }
3629
3630 int test_minimum_size(const char *file, u32 nodesize)
3631 {
3632         int fd;
3633         struct stat statbuf;
3634
3635         fd = open(file, O_RDONLY);
3636         if (fd < 0)
3637                 return -errno;
3638         if (stat(file, &statbuf) < 0) {
3639                 close(fd);
3640                 return -errno;
3641         }
3642         if (btrfs_device_size(fd, &statbuf) < btrfs_min_dev_size(nodesize)) {
3643                 close(fd);
3644                 return 1;
3645         }
3646         close(fd);
3647         return 0;
3648 }
3649
3650
3651 /*
3652  * Test if path is a directory
3653  * Returns:
3654  *   0 - path exists but it is not a directory
3655  *   1 - path exists and it is a directory
3656  * < 0 - error
3657  */
3658 int test_isdir(const char *path)
3659 {
3660         struct stat st;
3661         int ret;
3662
3663         ret = stat(path, &st);
3664         if (ret < 0)
3665                 return -errno;
3666
3667         return !!S_ISDIR(st.st_mode);
3668 }
3669
3670 void units_set_mode(unsigned *units, unsigned mode)
3671 {
3672         unsigned base = *units & UNITS_MODE_MASK;
3673
3674         *units = base | mode;
3675 }
3676
3677 void units_set_base(unsigned *units, unsigned base)
3678 {
3679         unsigned mode = *units & ~UNITS_MODE_MASK;
3680
3681         *units = base | mode;
3682 }
3683
3684 int find_next_key(struct btrfs_path *path, struct btrfs_key *key)
3685 {
3686         int level;
3687
3688         for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
3689                 if (!path->nodes[level])
3690                         break;
3691                 if (path->slots[level] + 1 >=
3692                     btrfs_header_nritems(path->nodes[level]))
3693                         continue;
3694                 if (level == 0)
3695                         btrfs_item_key_to_cpu(path->nodes[level], key,
3696                                               path->slots[level] + 1);
3697                 else
3698                         btrfs_node_key_to_cpu(path->nodes[level], key,
3699                                               path->slots[level] + 1);
3700                 return 0;
3701         }
3702         return 1;
3703 }
3704
3705 const char* btrfs_group_type_str(u64 flag)
3706 {
3707         u64 mask = BTRFS_BLOCK_GROUP_TYPE_MASK |
3708                 BTRFS_SPACE_INFO_GLOBAL_RSV;
3709
3710         switch (flag & mask) {
3711         case BTRFS_BLOCK_GROUP_DATA:
3712                 return "Data";
3713         case BTRFS_BLOCK_GROUP_SYSTEM:
3714                 return "System";
3715         case BTRFS_BLOCK_GROUP_METADATA:
3716                 return "Metadata";
3717         case BTRFS_BLOCK_GROUP_DATA|BTRFS_BLOCK_GROUP_METADATA:
3718                 return "Data+Metadata";
3719         case BTRFS_SPACE_INFO_GLOBAL_RSV:
3720                 return "GlobalReserve";
3721         default:
3722                 return "unknown";
3723         }
3724 }
3725
3726 const char* btrfs_group_profile_str(u64 flag)
3727 {
3728         switch (flag & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
3729         case 0:
3730                 return "single";
3731         case BTRFS_BLOCK_GROUP_RAID0:
3732                 return "RAID0";
3733         case BTRFS_BLOCK_GROUP_RAID1:
3734                 return "RAID1";
3735         case BTRFS_BLOCK_GROUP_RAID5:
3736                 return "RAID5";
3737         case BTRFS_BLOCK_GROUP_RAID6:
3738                 return "RAID6";
3739         case BTRFS_BLOCK_GROUP_DUP:
3740                 return "DUP";
3741         case BTRFS_BLOCK_GROUP_RAID10:
3742                 return "RAID10";
3743         default:
3744                 return "unknown";
3745         }
3746 }
3747
3748 u64 disk_size(const char *path)
3749 {
3750         struct statfs sfs;
3751
3752         if (statfs(path, &sfs) < 0)
3753                 return 0;
3754         else
3755                 return sfs.f_bsize * sfs.f_blocks;
3756 }
3757
3758 u64 get_partition_size(const char *dev)
3759 {
3760         u64 result;
3761         int fd = open(dev, O_RDONLY);
3762
3763         if (fd < 0)
3764                 return 0;
3765         if (ioctl(fd, BLKGETSIZE64, &result) < 0) {
3766                 close(fd);
3767                 return 0;
3768         }
3769         close(fd);
3770
3771         return result;
3772 }
3773
3774 int btrfs_tree_search2_ioctl_supported(int fd)
3775 {
3776         struct btrfs_ioctl_search_args_v2 *args2;
3777         struct btrfs_ioctl_search_key *sk;
3778         int args2_size = 1024;
3779         char args2_buf[args2_size];
3780         int ret;
3781         static int v2_supported = -1;
3782
3783         if (v2_supported != -1)
3784                 return v2_supported;
3785
3786         args2 = (struct btrfs_ioctl_search_args_v2 *)args2_buf;
3787         sk = &(args2->key);
3788
3789         /*
3790          * Search for the extent tree item in the root tree.
3791          */
3792         sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
3793         sk->min_objectid = BTRFS_EXTENT_TREE_OBJECTID;
3794         sk->max_objectid = BTRFS_EXTENT_TREE_OBJECTID;
3795         sk->min_type = BTRFS_ROOT_ITEM_KEY;
3796         sk->max_type = BTRFS_ROOT_ITEM_KEY;
3797         sk->min_offset = 0;
3798         sk->max_offset = (u64)-1;
3799         sk->min_transid = 0;
3800         sk->max_transid = (u64)-1;
3801         sk->nr_items = 1;
3802         args2->buf_size = args2_size - sizeof(struct btrfs_ioctl_search_args_v2);
3803         ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH_V2, args2);
3804         if (ret == -EOPNOTSUPP)
3805                 v2_supported = 0;
3806         else if (ret == 0)
3807                 v2_supported = 1;
3808         else
3809                 return ret;
3810
3811         return v2_supported;
3812 }
3813
3814 int btrfs_check_nodesize(u32 nodesize, u32 sectorsize, u64 features)
3815 {
3816         if (nodesize < sectorsize) {
3817                 error("illegal nodesize %u (smaller than %u)",
3818                                 nodesize, sectorsize);
3819                 return -1;
3820         } else if (nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
3821                 error("illegal nodesize %u (larger than %u)",
3822                         nodesize, BTRFS_MAX_METADATA_BLOCKSIZE);
3823                 return -1;
3824         } else if (nodesize & (sectorsize - 1)) {
3825                 error("illegal nodesize %u (not aligned to %u)",
3826                         nodesize, sectorsize);
3827                 return -1;
3828         } else if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS &&
3829                    nodesize != sectorsize) {
3830                 error("illegal nodesize %u (not equal to %u for mixed block group)",
3831                         nodesize, sectorsize);
3832                 return -1;
3833         }
3834         return 0;
3835 }
3836
3837 /*
3838  * Copy a path argument from SRC to DEST and check the SRC length if it's at
3839  * most PATH_MAX and fits into DEST. DESTLEN is supposed to be exact size of
3840  * the buffer.
3841  * The destination buffer is zero terminated.
3842  * Return < 0 for error, 0 otherwise.
3843  */
3844 int arg_copy_path(char *dest, const char *src, int destlen)
3845 {
3846         size_t len = strlen(src);
3847
3848         if (len >= PATH_MAX || len >= destlen)
3849                 return -ENAMETOOLONG;
3850
3851         __strncpy_null(dest, src, destlen);
3852
3853         return 0;
3854 }
3855
3856 unsigned int get_unit_mode_from_arg(int *argc, char *argv[], int df_mode)
3857 {
3858         unsigned int unit_mode = UNITS_DEFAULT;
3859         int arg_i;
3860         int arg_end;
3861
3862         for (arg_i = 0; arg_i < *argc; arg_i++) {
3863                 if (!strcmp(argv[arg_i], "--"))
3864                         break;
3865
3866                 if (!strcmp(argv[arg_i], "--raw")) {
3867                         unit_mode = UNITS_RAW;
3868                         argv[arg_i] = NULL;
3869                         continue;
3870                 }
3871                 if (!strcmp(argv[arg_i], "--human-readable")) {
3872                         unit_mode = UNITS_HUMAN_BINARY;
3873                         argv[arg_i] = NULL;
3874                         continue;
3875                 }
3876
3877                 if (!strcmp(argv[arg_i], "--iec")) {
3878                         units_set_mode(&unit_mode, UNITS_BINARY);
3879                         argv[arg_i] = NULL;
3880                         continue;
3881                 }
3882                 if (!strcmp(argv[arg_i], "--si")) {
3883                         units_set_mode(&unit_mode, UNITS_DECIMAL);
3884                         argv[arg_i] = NULL;
3885                         continue;
3886                 }
3887
3888                 if (!strcmp(argv[arg_i], "--kbytes")) {
3889                         units_set_base(&unit_mode, UNITS_KBYTES);
3890                         argv[arg_i] = NULL;
3891                         continue;
3892                 }
3893                 if (!strcmp(argv[arg_i], "--mbytes")) {
3894                         units_set_base(&unit_mode, UNITS_MBYTES);
3895                         argv[arg_i] = NULL;
3896                         continue;
3897                 }
3898                 if (!strcmp(argv[arg_i], "--gbytes")) {
3899                         units_set_base(&unit_mode, UNITS_GBYTES);
3900                         argv[arg_i] = NULL;
3901                         continue;
3902                 }
3903                 if (!strcmp(argv[arg_i], "--tbytes")) {
3904                         units_set_base(&unit_mode, UNITS_TBYTES);
3905                         argv[arg_i] = NULL;
3906                         continue;
3907                 }
3908
3909                 if (!df_mode)
3910                         continue;
3911
3912                 if (!strcmp(argv[arg_i], "-b")) {
3913                         unit_mode = UNITS_RAW;
3914                         argv[arg_i] = NULL;
3915                         continue;
3916                 }
3917                 if (!strcmp(argv[arg_i], "-h")) {
3918                         unit_mode = UNITS_HUMAN_BINARY;
3919                         argv[arg_i] = NULL;
3920                         continue;
3921                 }
3922                 if (!strcmp(argv[arg_i], "-H")) {
3923                         unit_mode = UNITS_HUMAN_DECIMAL;
3924                         argv[arg_i] = NULL;
3925                         continue;
3926                 }
3927                 if (!strcmp(argv[arg_i], "-k")) {
3928                         units_set_base(&unit_mode, UNITS_KBYTES);
3929                         argv[arg_i] = NULL;
3930                         continue;
3931                 }
3932                 if (!strcmp(argv[arg_i], "-m")) {
3933                         units_set_base(&unit_mode, UNITS_MBYTES);
3934                         argv[arg_i] = NULL;
3935                         continue;
3936                 }
3937                 if (!strcmp(argv[arg_i], "-g")) {
3938                         units_set_base(&unit_mode, UNITS_GBYTES);
3939                         argv[arg_i] = NULL;
3940                         continue;
3941                 }
3942                 if (!strcmp(argv[arg_i], "-t")) {
3943                         units_set_base(&unit_mode, UNITS_TBYTES);
3944                         argv[arg_i] = NULL;
3945                         continue;
3946                 }
3947         }
3948
3949         for (arg_i = 0, arg_end = 0; arg_i < *argc; arg_i++) {
3950                 if (!argv[arg_i])
3951                         continue;
3952                 argv[arg_end] = argv[arg_i];
3953                 arg_end++;
3954         }
3955
3956         *argc = arg_end;
3957
3958         return unit_mode;
3959 }
3960
3961 int string_is_numerical(const char *str)
3962 {
3963         if (!(*str >= '0' && *str <= '9'))
3964                 return 0;
3965         while (*str >= '0' && *str <= '9')
3966                 str++;
3967         if (*str != '\0')
3968                 return 0;
3969         return 1;
3970 }
3971
3972 /*
3973  * Preprocess @argv with getopt_long to reorder options and consume the "--"
3974  * option separator.
3975  * Unknown short and long options are reported, optionally the @usage is printed
3976  * before exit.
3977  */
3978 void clean_args_no_options(int argc, char *argv[], const char * const *usagestr)
3979 {
3980         static const struct option long_options[] = {
3981                 {NULL, 0, NULL, 0}
3982         };
3983
3984         while (1) {
3985                 int c = getopt_long(argc, argv, "", long_options, NULL);
3986
3987                 if (c < 0)
3988                         break;
3989
3990                 switch (c) {
3991                 default:
3992                         if (usagestr)
3993                                 usage(usagestr);
3994                 }
3995         }
3996 }
3997
3998 /*
3999  * Same as clean_args_no_options but pass through arguments that could look
4000  * like short options. Eg. reisze which takes a negative resize argument like
4001  * '-123M' .
4002  *
4003  * This accepts only two forms:
4004  * - "-- option1 option2 ..."
4005  * - "option1 option2 ..."
4006  */
4007 void clean_args_no_options_relaxed(int argc, char *argv[], const char * const *usagestr)
4008 {
4009         if (argc <= 1)
4010                 return;
4011
4012         if (strcmp(argv[1], "--") == 0)
4013                 optind = 2;
4014 }
4015
4016 /* Subvolume helper functions */
4017 /*
4018  * test if name is a correct subvolume name
4019  * this function return
4020  * 0-> name is not a correct subvolume name
4021  * 1-> name is a correct subvolume name
4022  */
4023 int test_issubvolname(const char *name)
4024 {
4025         return name[0] != '\0' && !strchr(name, '/') &&
4026                 strcmp(name, ".") && strcmp(name, "..");
4027 }
4028
4029 /*
4030  * Test if path is a subvolume
4031  * Returns:
4032  *   0 - path exists but it is not a subvolume
4033  *   1 - path exists and it is  a subvolume
4034  * < 0 - error
4035  */
4036 int test_issubvolume(const char *path)
4037 {
4038         struct stat     st;
4039         struct statfs stfs;
4040         int             res;
4041
4042         res = stat(path, &st);
4043         if (res < 0)
4044                 return -errno;
4045
4046         if (st.st_ino != BTRFS_FIRST_FREE_OBJECTID || !S_ISDIR(st.st_mode))
4047                 return 0;
4048
4049         res = statfs(path, &stfs);
4050         if (res < 0)
4051                 return -errno;
4052
4053         return (int)stfs.f_type == BTRFS_SUPER_MAGIC;
4054 }
4055
4056 const char *subvol_strip_mountpoint(const char *mnt, const char *full_path)
4057 {
4058         int len = strlen(mnt);
4059         if (!len)
4060                 return full_path;
4061
4062         if (mnt[len - 1] != '/')
4063                 len += 1;
4064
4065         return full_path + len;
4066 }
4067
4068 /*
4069  * Returns
4070  * <0: Std error
4071  * 0: All fine
4072  * 1: Error; and error info printed to the terminal. Fixme.
4073  * 2: If the fullpath is root tree instead of subvol tree
4074  */
4075 int get_subvol_info(const char *fullpath, struct root_info *get_ri)
4076 {
4077         u64 sv_id;
4078         int ret = 1;
4079         int fd = -1;
4080         int mntfd = -1;
4081         char *mnt = NULL;
4082         const char *svpath = NULL;
4083         DIR *dirstream1 = NULL;
4084         DIR *dirstream2 = NULL;
4085
4086         ret = test_issubvolume(fullpath);
4087         if (ret < 0)
4088                 return ret;
4089         if (!ret) {
4090                 error("not a subvolume: %s", fullpath);
4091                 return 1;
4092         }
4093
4094         ret = find_mount_root(fullpath, &mnt);
4095         if (ret < 0)
4096                 return ret;
4097         if (ret > 0) {
4098                 error("%s doesn't belong to btrfs mount point", fullpath);
4099                 return 1;
4100         }
4101         ret = 1;
4102         svpath = subvol_strip_mountpoint(mnt, fullpath);
4103
4104         fd = btrfs_open_dir(fullpath, &dirstream1, 1);
4105         if (fd < 0)
4106                 goto out;
4107
4108         ret = btrfs_list_get_path_rootid(fd, &sv_id);
4109         if (ret) {
4110                 error("can't get rootid for '%s'", fullpath);
4111                 goto out;
4112         }
4113
4114         mntfd = btrfs_open_dir(mnt, &dirstream2, 1);
4115         if (mntfd < 0)
4116                 goto out;
4117
4118         if (sv_id == BTRFS_FS_TREE_OBJECTID) {
4119                 ret = 2;
4120                 /*
4121                  * So that caller may decide if thats an error or just fine.
4122                  */
4123                 goto out;
4124         }
4125
4126         memset(get_ri, 0, sizeof(*get_ri));
4127         get_ri->root_id = sv_id;
4128
4129         ret = btrfs_get_subvol(mntfd, get_ri);
4130         if (ret)
4131                 error("can't find '%s': %d", svpath, ret);
4132
4133 out:
4134         close_file_or_dir(mntfd, dirstream2);
4135         close_file_or_dir(fd, dirstream1);
4136         free(mnt);
4137
4138         return ret;
4139 }
4140
4141 void init_rand_seed(u64 seed)
4142 {
4143         int i;
4144
4145         /* only use the last 48 bits */
4146         for (i = 0; i < 3; i++) {
4147                 rand_seed[i] = (unsigned short)(seed ^ (unsigned short)(-1));
4148                 seed >>= 16;
4149         }
4150         rand_seed_initlized = 1;
4151 }
4152
4153 static void __init_seed(void)
4154 {
4155         struct timeval tv;
4156         int ret;
4157         int fd;
4158
4159         if(rand_seed_initlized)
4160                 return;
4161         /* Use urandom as primary seed source. */
4162         fd = open("/dev/urandom", O_RDONLY);
4163         if (fd >= 0) {
4164                 ret = read(fd, rand_seed, sizeof(rand_seed));
4165                 close(fd);
4166                 if (ret < sizeof(rand_seed))
4167                         goto fallback;
4168         } else {
4169 fallback:
4170                 /* Use time and pid as fallback seed */
4171                 warning("failed to read /dev/urandom, use time and pid as random seed");
4172                 gettimeofday(&tv, 0);
4173                 rand_seed[0] = getpid() ^ (tv.tv_sec & 0xFFFF);
4174                 rand_seed[1] = getppid() ^ (tv.tv_usec & 0xFFFF);
4175                 rand_seed[2] = (tv.tv_sec ^ tv.tv_usec) >> 16;
4176         }
4177         rand_seed_initlized = 1;
4178 }
4179
4180 u32 rand_u32(void)
4181 {
4182         __init_seed();
4183         /*
4184          * Don't use nrand48, its range is [0,2^31) The highest bit will alwasy
4185          * be 0.  Use jrand48 to include the highest bit.
4186          */
4187         return (u32)jrand48(rand_seed);
4188 }
4189
4190 unsigned int rand_range(unsigned int upper)
4191 {
4192         __init_seed();
4193         /*
4194          * Use the full 48bits to mod, which would be more uniformly
4195          * distributed
4196          */
4197         return (unsigned int)(jrand48(rand_seed) % upper);
4198 }