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