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