mkfs/rootdir.c

   1 /*
   2  * Copyright (C) 2017 SUSE.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program.
  15  */
  16
  17 #include "kerncompat.h"
  18 #include "androidcompat.h"
  19
  20 #include <sys/stat.h>
  21 #include <sys/types.h>
  22 #include <sys/xattr.h>
  23 #include <linux/limits.h>
  24 #include <dirent.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <ftw.h>
  28 #include "ctree.h"
  29 #include "volumes.h"
  30 #include "internal.h"
  31 #include "disk-io.h"
  32 #include "messages.h"
  33 #include "transaction.h"
  34 #include "utils.h"
  35 #include "mkfs/rootdir.h"
  36 #include "mkfs/common.h"
  37 #include "send-utils.h"
  38
  39 static u32 fs_block_size;
  40
  41 static u64 index_cnt = 2;
  42
  43 /*
  44  * Size estimate will be done using the following data:
  45  * 1) Number of inodes
  46  *    Since we will later shrink the fs, over-estimate is completely fine here
  47  *    as long as our estimate ensures we can populate the image without ENOSPC.
  48  *    So we only record how many inodes there are, and account the maximum
  49  *    space for each inode.
  50  *
  51  * 2) Data space for each (regular) inode
  52  *    To estimate data chunk size.
  53  *    Don't care if it can fit as an inline extent.
  54  *    Always round them up to sectorsize.
  55  */
  56 static u64 ftw_meta_nr_inode;
  57 static u64 ftw_data_size;
  58
  59 static int add_directory_items(struct btrfs_trans_handle *trans,
  60                                struct btrfs_root *root, u64 objectid,
  61                                ino_t parent_inum, const char *name,
  62                                struct stat *st, int *dir_index_cnt)
  63 {
  64         int ret;
  65         int name_len;
  66         struct btrfs_key location;
  67         u8 filetype = 0;
  68
  69         name_len = strlen(name);
  70
  71         location.objectid = objectid;
  72         location.offset = 0;
  73         location.type = BTRFS_INODE_ITEM_KEY;
  74
  75         if (S_ISDIR(st->st_mode))
  76                 filetype = BTRFS_FT_DIR;
  77         if (S_ISREG(st->st_mode))
  78                 filetype = BTRFS_FT_REG_FILE;
  79         if (S_ISLNK(st->st_mode))
  80                 filetype = BTRFS_FT_SYMLINK;
  81         if (S_ISSOCK(st->st_mode))
  82                 filetype = BTRFS_FT_SOCK;
  83         if (S_ISCHR(st->st_mode))
  84                 filetype = BTRFS_FT_CHRDEV;
  85         if (S_ISBLK(st->st_mode))
  86                 filetype = BTRFS_FT_BLKDEV;
  87         if (S_ISFIFO(st->st_mode))
  88                 filetype = BTRFS_FT_FIFO;
  89
  90         ret = btrfs_insert_dir_item(trans, root, name, name_len,
  91                                     parent_inum, &location,
  92                                     filetype, index_cnt);
  93         if (ret)
  94                 return ret;
  95         ret = btrfs_insert_inode_ref(trans, root, name, name_len,
  96                                      objectid, parent_inum, index_cnt);
  97         *dir_index_cnt = index_cnt;
  98         index_cnt++;
  99
 100         return ret;
 101 }
 102
 103 static int fill_inode_item(struct btrfs_trans_handle *trans,
 104                            struct btrfs_root *root,
 105                            struct btrfs_inode_item *dst, struct stat *src)
 106 {
 107         u64 blocks = 0;
 108         u64 sectorsize = root->fs_info->sectorsize;
 109
 110         /*
 111          * btrfs_inode_item has some reserved fields
 112          * and represents on-disk inode entry, so
 113          * zero everything to prevent information leak
 114          */
 115         memset(dst, 0, sizeof(*dst));
 116
 117         btrfs_set_stack_inode_generation(dst, trans->transid);
 118         btrfs_set_stack_inode_size(dst, src->st_size);
 119         btrfs_set_stack_inode_nbytes(dst, 0);
 120         btrfs_set_stack_inode_block_group(dst, 0);
 121         btrfs_set_stack_inode_nlink(dst, src->st_nlink);
 122         btrfs_set_stack_inode_uid(dst, src->st_uid);
 123         btrfs_set_stack_inode_gid(dst, src->st_gid);
 124         btrfs_set_stack_inode_mode(dst, src->st_mode);
 125         btrfs_set_stack_inode_rdev(dst, 0);
 126         btrfs_set_stack_inode_flags(dst, 0);
 127         btrfs_set_stack_timespec_sec(&dst->atime, src->st_atime);
 128         btrfs_set_stack_timespec_nsec(&dst->atime, 0);
 129         btrfs_set_stack_timespec_sec(&dst->ctime, src->st_ctime);
 130         btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
 131         btrfs_set_stack_timespec_sec(&dst->mtime, src->st_mtime);
 132         btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
 133         btrfs_set_stack_timespec_sec(&dst->otime, 0);
 134         btrfs_set_stack_timespec_nsec(&dst->otime, 0);
 135
 136         if (S_ISDIR(src->st_mode)) {
 137                 btrfs_set_stack_inode_size(dst, 0);
 138                 btrfs_set_stack_inode_nlink(dst, 1);
 139         }
 140         if (S_ISREG(src->st_mode)) {
 141                 btrfs_set_stack_inode_size(dst, (u64)src->st_size);
 142                 if (src->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root))
 143                         btrfs_set_stack_inode_nbytes(dst, src->st_size);
 144                 else {
 145                         blocks = src->st_size / sectorsize;
 146                         if (src->st_size % sectorsize)
 147                                 blocks += 1;
 148                         blocks *= sectorsize;
 149                         btrfs_set_stack_inode_nbytes(dst, blocks);
 150                 }
 151         }
 152         if (S_ISLNK(src->st_mode))
 153                 btrfs_set_stack_inode_nbytes(dst, src->st_size + 1);
 154
 155         return 0;
 156 }
 157
 158 static int directory_select(const struct direct *entry)
 159 {
 160         if (entry->d_name[0] == '.' &&
 161                 (entry->d_name[1] == 0 ||
 162                  (entry->d_name[1] == '.' && entry->d_name[2] == 0)))
 163                 return 0;
 164         return 1;
 165 }
 166
 167 static void free_namelist(struct direct **files, int count)
 168 {
 169         int i;
 170
 171         if (count < 0)
 172                 return;
 173
 174         for (i = 0; i < count; ++i)
 175                 free(files[i]);
 176         free(files);
 177 }
 178
 179 static u64 calculate_dir_inode_size(const char *dirname)
 180 {
 181         int count, i;
 182         struct direct **files, *cur_file;
 183         u64 dir_inode_size = 0;
 184
 185         count = scandir(dirname, &files, directory_select, NULL);
 186
 187         for (i = 0; i < count; i++) {
 188                 cur_file = files[i];
 189                 dir_inode_size += strlen(cur_file->d_name);
 190         }
 191
 192         free_namelist(files, count);
 193
 194         dir_inode_size *= 2;
 195         return dir_inode_size;
 196 }
 197
 198 static int add_inode_items(struct btrfs_trans_handle *trans,
 199                            struct btrfs_root *root,
 200                            struct stat *st, const char *name,
 201                            u64 self_objectid,
 202                            struct btrfs_inode_item *inode_ret)
 203 {
 204         int ret;
 205         struct btrfs_inode_item btrfs_inode;
 206         u64 objectid;
 207         u64 inode_size = 0;
 208
 209         fill_inode_item(trans, root, &btrfs_inode, st);
 210         objectid = self_objectid;
 211
 212         if (S_ISDIR(st->st_mode)) {
 213                 inode_size = calculate_dir_inode_size(name);
 214                 btrfs_set_stack_inode_size(&btrfs_inode, inode_size);
 215         }
 216
 217         ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
 218
 219         *inode_ret = btrfs_inode;
 220         return ret;
 221 }
 222
 223 static int add_xattr_item(struct btrfs_trans_handle *trans,
 224                           struct btrfs_root *root, u64 objectid,
 225                           const char *file_name)
 226 {
 227         int ret;
 228         int cur_name_len;
 229         char xattr_list[XATTR_LIST_MAX];
 230         char *cur_name;
 231         char cur_value[XATTR_SIZE_MAX];
 232         char delimiter = '\0';
 233         char *next_location = xattr_list;
 234
 235         ret = llistxattr(file_name, xattr_list, XATTR_LIST_MAX);
 236         if (ret < 0) {
 237                 if (errno == ENOTSUP)
 238                         return 0;
 239                 error("getting a list of xattr failed for %s: %s", file_name,
 240                                 strerror(errno));
 241                 return ret;
 242         }
 243         if (ret == 0)
 244                 return ret;
 245
 246         cur_name = strtok(xattr_list, &delimiter);
 247         while (cur_name != NULL) {
 248                 cur_name_len = strlen(cur_name);
 249                 next_location += cur_name_len + 1;
 250
 251                 ret = getxattr(file_name, cur_name, cur_value, XATTR_SIZE_MAX);
 252                 if (ret < 0) {
 253                         if (errno == ENOTSUP)
 254                                 return 0;
 255                         error("gettig a xattr value failed for %s attr %s: %s",
 256                                 file_name, cur_name, strerror(errno));
 257                         return ret;
 258                 }
 259
 260                 ret = btrfs_insert_xattr_item(trans, root, cur_name,
 261                                               cur_name_len, cur_value,
 262                                               ret, objectid);
 263                 if (ret) {
 264                         error("inserting a xattr item failed for %s: %s",
 265                                         file_name, strerror(-ret));
 266                 }
 267
 268                 cur_name = strtok(next_location, &delimiter);
 269         }
 270
 271         return ret;
 272 }
 273
 274 static int add_symbolic_link(struct btrfs_trans_handle *trans,
 275                              struct btrfs_root *root,
 276                              u64 objectid, const char *path_name)
 277 {
 278         int ret;
 279         char buf[PATH_MAX];
 280
 281         ret = readlink(path_name, buf, sizeof(buf));
 282         if (ret <= 0) {
 283                 error("readlink failed for %s: %s", path_name, strerror(errno));
 284                 goto fail;
 285         }
 286         if (ret >= sizeof(buf)) {
 287                 error("symlink too long for %s", path_name);
 288                 ret = -1;
 289                 goto fail;
 290         }
 291
 292         buf[ret] = '\0'; /* readlink does not do it for us */
 293         ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
 294                                          buf, ret + 1);
 295 fail:
 296         return ret;
 297 }
 298
 299 static int add_file_items(struct btrfs_trans_handle *trans,
 300                           struct btrfs_root *root,
 301                           struct btrfs_inode_item *btrfs_inode, u64 objectid,
 302                           struct stat *st, const char *path_name)
 303 {
 304         int ret = -1;
 305         ssize_t ret_read;
 306         u64 bytes_read = 0;
 307         struct btrfs_key key;
 308         int blocks;
 309         u32 sectorsize = root->fs_info->sectorsize;
 310         u64 first_block = 0;
 311         u64 file_pos = 0;
 312         u64 cur_bytes;
 313         u64 total_bytes;
 314         struct extent_buffer *eb = NULL;
 315         int fd;
 316
 317         if (st->st_size == 0)
 318                 return 0;
 319
 320         fd = open(path_name, O_RDONLY);
 321         if (fd == -1) {
 322                 error("cannot open %s: %s", path_name, strerror(errno));
 323                 return ret;
 324         }
 325
 326         blocks = st->st_size / sectorsize;
 327         if (st->st_size % sectorsize)
 328                 blocks += 1;
 329
 330         if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
 331                 char *buffer = malloc(st->st_size);
 332
 333                 if (!buffer) {
 334                         ret = -ENOMEM;
 335                         goto end;
 336                 }
 337
 338                 ret_read = pread64(fd, buffer, st->st_size, bytes_read);
 339                 if (ret_read == -1) {
 340                         error("cannot read %s at offset %llu length %llu: %s",
 341                                 path_name, (unsigned long long)bytes_read,
 342                                 (unsigned long long)st->st_size,
 343                                 strerror(errno));
 344                         free(buffer);
 345                         goto end;
 346                 }
 347
 348                 ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
 349                                                  buffer, st->st_size);
 350                 free(buffer);
 351                 goto end;
 352         }
 353
 354         /* round up our st_size to the FS blocksize */
 355         total_bytes = (u64)blocks * sectorsize;
 356
 357         /*
 358          * do our IO in extent buffers so it can work
 359          * against any raid type
 360          */
 361         eb = calloc(1, sizeof(*eb) + sectorsize);
 362         if (!eb) {
 363                 ret = -ENOMEM;
 364                 goto end;
 365         }
 366
 367 again:
 368
 369         /*
 370          * keep our extent size at 1MB max, this makes it easier to work inside
 371          * the tiny block groups created during mkfs
 372          */
 373         cur_bytes = min(total_bytes, (u64)SZ_1M);
 374         ret = btrfs_reserve_extent(trans, root, cur_bytes, 0, 0, (u64)-1,
 375                                    &key, 1);
 376         if (ret)
 377                 goto end;
 378
 379         first_block = key.objectid;
 380         bytes_read = 0;
 381
 382         while (bytes_read < cur_bytes) {
 383
 384                 memset(eb->data, 0, sectorsize);
 385
 386                 ret_read = pread64(fd, eb->data, sectorsize, file_pos +
 387                                    bytes_read);
 388                 if (ret_read == -1) {
 389                         error("cannot read %s at offset %llu length %llu: %s",
 390                                 path_name,
 391                                 (unsigned long long)file_pos + bytes_read,
 392                                 (unsigned long long)sectorsize,
 393                                 strerror(errno));
 394                         goto end;
 395                 }
 396
 397                 eb->start = first_block + bytes_read;
 398                 eb->len = sectorsize;
 399
 400                 /*
 401                  * we're doing the csum before we record the extent, but
 402                  * that's ok
 403                  */
 404                 ret = btrfs_csum_file_block(trans, root->fs_info->csum_root,
 405                                 first_block + bytes_read + sectorsize,
 406                                 first_block + bytes_read,
 407                                 eb->data, sectorsize);
 408                 if (ret)
 409                         goto end;
 410
 411                 ret = write_and_map_eb(root->fs_info, eb);
 412                 if (ret) {
 413                         error("failed to write %s", path_name);
 414                         goto end;
 415                 }
 416
 417                 bytes_read += sectorsize;
 418         }
 419
 420         if (bytes_read) {
 421                 ret = btrfs_record_file_extent(trans, root, objectid,
 422                                 btrfs_inode, file_pos, first_block, cur_bytes);
 423                 if (ret)
 424                         goto end;
 425
 426         }
 427
 428         file_pos += cur_bytes;
 429         total_bytes -= cur_bytes;
 430
 431         if (total_bytes)
 432                 goto again;
 433
 434 end:
 435         free(eb);
 436         close(fd);
 437         return ret;
 438 }
 439
 440 static int traverse_directory(struct btrfs_trans_handle *trans,
 441                               struct btrfs_root *root, const char *dir_name,
 442                               struct directory_name_entry *dir_head)
 443 {
 444         int ret = 0;
 445
 446         struct btrfs_inode_item cur_inode;
 447         struct btrfs_inode_item *inode_item;
 448         int count, i, dir_index_cnt;
 449         struct direct **files;
 450         struct stat st;
 451         struct directory_name_entry *dir_entry, *parent_dir_entry;
 452         struct direct *cur_file;
 453         ino_t parent_inum, cur_inum;
 454         ino_t highest_inum = 0;
 455         const char *parent_dir_name;
 456         char real_path[PATH_MAX];
 457         struct btrfs_path path;
 458         struct extent_buffer *leaf;
 459         struct btrfs_key root_dir_key;
 460         u64 root_dir_inode_size = 0;
 461
 462         /* Add list for source directory */
 463         dir_entry = malloc(sizeof(struct directory_name_entry));
 464         if (!dir_entry)
 465                 return -ENOMEM;
 466         dir_entry->dir_name = dir_name;
 467         dir_entry->path = realpath(dir_name, real_path);
 468         if (!dir_entry->path) {
 469                 error("realpath  failed for %s: %s", dir_name, strerror(errno));
 470                 ret = -1;
 471                 goto fail_no_dir;
 472         }
 473
 474         parent_inum = highest_inum + BTRFS_FIRST_FREE_OBJECTID;
 475         dir_entry->inum = parent_inum;
 476         list_add_tail(&dir_entry->list, &dir_head->list);
 477
 478         btrfs_init_path(&path);
 479
 480         root_dir_key.objectid = btrfs_root_dirid(&root->root_item);
 481         root_dir_key.offset = 0;
 482         root_dir_key.type = BTRFS_INODE_ITEM_KEY;
 483         ret = btrfs_lookup_inode(trans, root, &path, &root_dir_key, 1);
 484         if (ret) {
 485                 error("failed to lookup root dir: %d", ret);
 486                 goto fail_no_dir;
 487         }
 488
 489         leaf = path.nodes[0];
 490         inode_item = btrfs_item_ptr(leaf, path.slots[0],
 491                                     struct btrfs_inode_item);
 492
 493         root_dir_inode_size = calculate_dir_inode_size(dir_name);
 494         btrfs_set_inode_size(leaf, inode_item, root_dir_inode_size);
 495         btrfs_mark_buffer_dirty(leaf);
 496
 497         btrfs_release_path(&path);
 498
 499         do {
 500                 parent_dir_entry = list_entry(dir_head->list.next,
 501                                               struct directory_name_entry,
 502                                               list);
 503                 list_del(&parent_dir_entry->list);
 504
 505                 parent_inum = parent_dir_entry->inum;
 506                 parent_dir_name = parent_dir_entry->dir_name;
 507                 if (chdir(parent_dir_entry->path)) {
 508                         error("chdir failed for %s: %s",
 509                                 parent_dir_name, strerror(errno));
 510                         ret = -1;
 511                         goto fail_no_files;
 512                 }
 513
 514                 count = scandir(parent_dir_entry->path, &files,
 515                                 directory_select, NULL);
 516                 if (count == -1) {
 517                         error("scandir failed for %s: %s",
 518                                 parent_dir_name, strerror(errno));
 519                         ret = -1;
 520                         goto fail;
 521                 }
 522
 523                 for (i = 0; i < count; i++) {
 524                         cur_file = files[i];
 525
 526                         if (lstat(cur_file->d_name, &st) == -1) {
 527                                 error("lstat failed for %s: %s",
 528                                         cur_file->d_name, strerror(errno));
 529                                 ret = -1;
 530                                 goto fail;
 531                         }
 532
 533                         cur_inum = st.st_ino;
 534                         ret = add_directory_items(trans, root,
 535                                                   cur_inum, parent_inum,
 536                                                   cur_file->d_name,
 537                                                   &st, &dir_index_cnt);
 538                         if (ret) {
 539                                 error("unable to add directory items for %s: %d",
 540                                         cur_file->d_name, ret);
 541                                 goto fail;
 542                         }
 543
 544                         ret = add_inode_items(trans, root, &st,
 545                                               cur_file->d_name, cur_inum,
 546                                               &cur_inode);
 547                         if (ret == -EEXIST) {
 548                                 if (st.st_nlink <= 1) {
 549                                         error(
 550                         "item %s already exists but has wrong st_nlink %lu <= 1",
 551                                                 cur_file->d_name,
 552                                                 (unsigned long)st.st_nlink);
 553                                         goto fail;
 554                                 }
 555                                 continue;
 556                         }
 557                         if (ret) {
 558                                 error("unable to add inode items for %s: %d",
 559                                         cur_file->d_name, ret);
 560                                 goto fail;
 561                         }
 562
 563                         ret = add_xattr_item(trans, root,
 564                                              cur_inum, cur_file->d_name);
 565                         if (ret) {
 566                                 error("unable to add xattr items for %s: %d",
 567                                         cur_file->d_name, ret);
 568                                 if (ret != -ENOTSUP)
 569                                         goto fail;
 570                         }
 571
 572                         if (S_ISDIR(st.st_mode)) {
 573                                 char tmp[PATH_MAX];
 574
 575                                 dir_entry = malloc(sizeof(*dir_entry));
 576                                 if (!dir_entry) {
 577                                         ret = -ENOMEM;
 578                                         goto fail;
 579                                 }
 580                                 dir_entry->dir_name = cur_file->d_name;
 581                                 if (path_cat_out(tmp, parent_dir_entry->path,
 582                                                         cur_file->d_name)) {
 583                                         error("invalid path: %s/%s",
 584                                                         parent_dir_entry->path,
 585                                                         cur_file->d_name);
 586                                         ret = -EINVAL;
 587                                         goto fail;
 588                                 }
 589                                 dir_entry->path = strdup(tmp);
 590                                 if (!dir_entry->path) {
 591                                         error("not enough memory to store path");
 592                                         ret = -ENOMEM;
 593                                         goto fail;
 594                                 }
 595                                 dir_entry->inum = cur_inum;
 596                                 list_add_tail(&dir_entry->list,
 597                                               &dir_head->list);
 598                         } else if (S_ISREG(st.st_mode)) {
 599                                 ret = add_file_items(trans, root, &cur_inode,
 600                                                      cur_inum, &st,
 601                                                      cur_file->d_name);
 602                                 if (ret) {
 603                                         error("unable to add file items for %s: %d",
 604                                                 cur_file->d_name, ret);
 605                                         goto fail;
 606                                 }
 607                         } else if (S_ISLNK(st.st_mode)) {
 608                                 ret = add_symbolic_link(trans, root,
 609                                                 cur_inum, cur_file->d_name);
 610                                 if (ret) {
 611                                         error("unable to add symlink for %s: %d",
 612                                                 cur_file->d_name, ret);
 613                                         goto fail;
 614                                 }
 615                         }
 616                 }
 617
 618                 free_namelist(files, count);
 619                 free(parent_dir_entry);
 620
 621                 index_cnt = 2;
 622
 623         } while (!list_empty(&dir_head->list));
 624
 625 out:
 626         return !!ret;
 627 fail:
 628         free_namelist(files, count);
 629 fail_no_files:
 630         free(parent_dir_entry);
 631         goto out;
 632 fail_no_dir:
 633         free(dir_entry);
 634         goto out;
 635 }
 636
 637 int btrfs_mkfs_fill_dir(const char *source_dir, struct btrfs_root *root,
 638                         bool verbose)
 639 {
 640         int ret;
 641         struct btrfs_trans_handle *trans;
 642         struct stat root_st;
 643         struct directory_name_entry dir_head;
 644         struct directory_name_entry *dir_entry = NULL;
 645
 646         ret = lstat(source_dir, &root_st);
 647         if (ret) {
 648                 error("unable to lstat %s: %s", source_dir, strerror(errno));
 649                 ret = -errno;
 650                 goto out;
 651         }
 652
 653         INIT_LIST_HEAD(&dir_head.list);
 654
 655         trans = btrfs_start_transaction(root, 1);
 656         BUG_ON(IS_ERR(trans));
 657         ret = traverse_directory(trans, root, source_dir, &dir_head);
 658         if (ret) {
 659                 error("unable to traverse directory %s: %d", source_dir, ret);
 660                 goto fail;
 661         }
 662         ret = btrfs_commit_transaction(trans, root);
 663         if (ret) {
 664                 error("transaction commit failed: %d", ret);
 665                 goto out;
 666         }
 667
 668         if (verbose)
 669                 printf("Making image is completed.\n");
 670         return 0;
 671 fail:
 672         /*
 673          * Since we don't have btrfs_abort_transaction() yet, uncommitted trans
 674          * will trigger a BUG_ON().
 675          *
 676          * However before mkfs is fully finished, the magic number is invalid,
 677          * so even we commit transaction here, the fs still can't be mounted.
 678          *
 679          * To do a graceful error out, here we commit transaction as a
 680          * workaround.
 681          * Since we have already hit some problem, the return value doesn't
 682          * matter now.
 683          */
 684         btrfs_commit_transaction(trans, root);
 685         while (!list_empty(&dir_head.list)) {
 686                 dir_entry = list_entry(dir_head.list.next,
 687                                        struct directory_name_entry, list);
 688                 list_del(&dir_entry->list);
 689                 free(dir_entry);
 690         }
 691 out:
 692         return ret;
 693 }
 694
 695 static int ftw_add_entry_size(const char *fpath, const struct stat *st,
 696                               int type)
 697 {
 698         /*
 699          * Failed to read the directory, mostly due to EPERM.  Abort ASAP, so
 700          * we don't need to populate the fs.
 701          */
 702         if (type == FTW_DNR || type == FTW_NS)
 703                 return -EPERM;
 704
 705         if (S_ISREG(st->st_mode))
 706                 ftw_data_size += round_up(st->st_size, fs_block_size);
 707         ftw_meta_nr_inode++;
 708
 709         return 0;
 710 }
 711
 712 u64 btrfs_mkfs_size_dir(const char *dir_name, u32 sectorsize, u64 min_dev_size,
 713                         u64 meta_profile, u64 data_profile)
 714 {
 715         u64 total_size = 0;
 716         int ret;
 717
 718         u64 meta_size = 0;              /* Based on @ftw_meta_nr_inode */
 719         u64 meta_chunk_size = 0;        /* Based on @meta_size */
 720         u64 data_chunk_size = 0;        /* Based on @ftw_data_size */
 721
 722         u64 meta_threshold = SZ_8M;
 723         u64 data_threshold = SZ_8M;
 724
 725         float data_multipler = 1;
 726         float meta_multipler = 1;
 727
 728         fs_block_size = sectorsize;
 729         ftw_data_size = 0;
 730         ftw_meta_nr_inode = 0;
 731         ret = ftw(dir_name, ftw_add_entry_size, 10);
 732         if (ret < 0) {
 733                 error("ftw subdir walk of %s failed: %s", dir_name,
 734                         strerror(errno));
 735                 exit(1);
 736         }
 737
 738
 739         /*
 740          * Maximum metadata useage for every inode, which will be PATH_MAX
 741          * for the following items:
 742          * 1) DIR_ITEM
 743          * 2) DIR_INDEX
 744          * 3) INODE_REF
 745          *
 746          * Plus possible inline extent size, which is sectorsize.
 747          *
 748          * And finally, allow metadata usage to increase with data size.
 749          * Follow the old kernel 8:1 data:meta ratio.
 750          * This is especially important for --rootdir, as the file extent size
 751          * upper limit is 1M, instead of 128M in kernel.
 752          * This can bump meta usage easily.
 753          */
 754         meta_size = ftw_meta_nr_inode * (PATH_MAX * 3 + sectorsize) +
 755                     ftw_data_size / 8;
 756
 757         /* Minimal chunk size from btrfs_alloc_chunk(). */
 758         if (meta_profile & BTRFS_BLOCK_GROUP_DUP) {
 759                 meta_threshold = SZ_32M;
 760                 meta_multipler = 2;
 761         }
 762         if (data_profile & BTRFS_BLOCK_GROUP_DUP) {
 763                 data_threshold = SZ_64M;
 764                 data_multipler = 2;
 765         }
 766
 767         /*
 768          * Only when the usage is larger than the minimal chunk size (threshold)
 769          * we need to allocate new chunk, or the initial chunk in the image is
 770          * large enough.
 771          */
 772         if (meta_size > meta_threshold)
 773                 meta_chunk_size = (round_up(meta_size, meta_threshold) -
 774                                    meta_threshold) * meta_multipler;
 775         if (ftw_data_size > data_threshold)
 776                 data_chunk_size = (round_up(ftw_data_size, data_threshold) -
 777                                    data_threshold) * data_multipler;
 778
 779         total_size = data_chunk_size + meta_chunk_size + min_dev_size;
 780         return total_size;
 781 }
 782
 783 /*
 784  * Get the end position of the last device extent for given @devid;
 785  * @size_ret is exclsuive (means it should be aligned to sectorsize)
 786  */
 787 static int get_device_extent_end(struct btrfs_fs_info *fs_info,
 788                                  u64 devid, u64 *size_ret)
 789 {
 790         struct btrfs_root *dev_root = fs_info->dev_root;
 791         struct btrfs_key key;
 792         struct btrfs_path path;
 793         struct btrfs_dev_extent *de;
 794         int ret;
 795
 796         key.objectid = devid;
 797         key.type = BTRFS_DEV_EXTENT_KEY;
 798         key.offset = (u64)-1;
 799
 800         btrfs_init_path(&path);
 801         ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
 802         /* Not really possible */
 803         BUG_ON(ret == 0);
 804
 805         ret = btrfs_previous_item(dev_root, &path, devid, BTRFS_DEV_EXTENT_KEY);
 806         if (ret < 0)
 807                 goto out;
 808
 809         /* No dev_extent at all, not really possible for rootdir case */
 810         if (ret > 0) {
 811                 *size_ret = 0;
 812                 ret = -EUCLEAN;
 813                 goto out;
 814         }
 815
 816         btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
 817         de = btrfs_item_ptr(path.nodes[0], path.slots[0],
 818                             struct btrfs_dev_extent);
 819         *size_ret = key.offset + btrfs_dev_extent_length(path.nodes[0], de);
 820 out:
 821         btrfs_release_path(&path);
 822
 823         return ret;
 824 }
 825
 826 /*
 827  * Set device size to @new_size.
 828  *
 829  * Only used for --rootdir option.
 830  * We will need to reset the following values:
 831  * 1) dev item in chunk tree
 832  * 2) super->dev_item
 833  * 3) super->total_bytes
 834  */
 835 static int set_device_size(struct btrfs_fs_info *fs_info,
 836                            struct btrfs_device *device, u64 new_size)
 837 {
 838         struct btrfs_root *chunk_root = fs_info->chunk_root;
 839         struct btrfs_trans_handle *trans;
 840         struct btrfs_dev_item *di;
 841         struct btrfs_path path;
 842         struct btrfs_key key;
 843         int ret;
 844
 845         /*
 846          * Update in-meory device->total_bytes, so that at trans commit time,
 847          * super->dev_item will also get updated
 848          */
 849         device->total_bytes = new_size;
 850         btrfs_init_path(&path);
 851
 852         /* Update device item in chunk tree */
 853         trans = btrfs_start_transaction(chunk_root, 1);
 854         if (IS_ERR(trans)) {
 855                 ret = PTR_ERR(trans);
 856                 error("failed to start transaction: %d (%s)", ret,
 857                         strerror(-ret));
 858                 return ret;
 859         }
 860         key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
 861         key.type = BTRFS_DEV_ITEM_KEY;
 862         key.offset = device->devid;
 863
 864         ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 1);
 865         if (ret < 0)
 866                 goto err;
 867         if (ret > 0)
 868                 ret = -ENOENT;
 869         di = btrfs_item_ptr(path.nodes[0], path.slots[0],
 870                             struct btrfs_dev_item);
 871         btrfs_set_device_total_bytes(path.nodes[0], di, new_size);
 872         btrfs_mark_buffer_dirty(path.nodes[0]);
 873
 874         /*
 875          * Update super->total_bytes, since it's only used for --rootdir,
 876          * there is only one device, just use the @new_size.
 877          */
 878         btrfs_set_super_total_bytes(fs_info->super_copy, new_size);
 879
 880         /*
 881          * Commit transaction to reflect the updated super->total_bytes and
 882          * super->dev_item
 883          */
 884         ret = btrfs_commit_transaction(trans, chunk_root);
 885         if (ret < 0)
 886                 error("failed to commit current transaction: %d (%s)",
 887                         ret, strerror(-ret));
 888         btrfs_release_path(&path);
 889         return ret;
 890
 891 err:
 892         btrfs_release_path(&path);
 893         /*
 894          * Committing the transaction here won't cause problems since the fs
 895          * still has an invalid magic number, and something wrong already
 896          * happened, we don't care the return value anyway.
 897          */
 898         btrfs_commit_transaction(trans, chunk_root);
 899         return ret;
 900 }
 901
 902 int btrfs_mkfs_shrink_fs(struct btrfs_fs_info *fs_info, u64 *new_size_ret,
 903                          bool shrink_file_size)
 904 {
 905         u64 new_size;
 906         struct btrfs_device *device;
 907         struct list_head *cur;
 908         struct stat64 file_stat;
 909         int nr_devs = 0;
 910         int ret;
 911
 912         list_for_each(cur, &fs_info->fs_devices->devices)
 913                 nr_devs++;
 914
 915         if (nr_devs > 1) {
 916                 error("cannot shrink fs with more than 1 device");
 917                 return -ENOTTY;
 918         }
 919
 920         ret = get_device_extent_end(fs_info, 1, &new_size);
 921         if (ret < 0) {
 922                 error("failed to get minimal device size: %d (%s)",
 923                         ret, strerror(-ret));
 924                 return ret;
 925         }
 926
 927         BUG_ON(!IS_ALIGNED(new_size, fs_info->sectorsize));
 928
 929         device = list_entry(fs_info->fs_devices->devices.next,
 930                            struct btrfs_device, dev_list);
 931         ret = set_device_size(fs_info, device, new_size);
 932         if (ret < 0)
 933                 return ret;
 934         if (new_size_ret)
 935                 *new_size_ret = new_size;
 936
 937         if (shrink_file_size) {
 938                 ret = fstat64(device->fd, &file_stat);
 939                 if (ret < 0) {
 940                         error("failed to stat devid %llu: %s", device->devid,
 941                                 strerror(errno));
 942                         return ret;
 943                 }
 944                 if (!S_ISREG(file_stat.st_mode))
 945                         return ret;
 946                 ret = ftruncate64(device->fd, new_size);
 947                 if (ret < 0) {
 948                         error("failed to truncate device file of devid %llu: %s",
 949                                 device->devid, strerror(errno));
 950                         return ret;
 951                 }
 952         }
 953         return ret;
 954 }