utils.c

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