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