libbtrfsutil/subvolume.c

   1 /*
   2  * Copyright (C) 2018 Facebook
   3  *
   4  * This file is part of libbtrfsutil.
   5  *
   6  * libbtrfsutil is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * libbtrfsutil is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with libbtrfsutil.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28 #include <sys/vfs.h>
  29 #include <linux/magic.h>
  30 #include "stubs.h"
  31
  32 #include "btrfsutil_internal.h"
  33
  34 /*
  35  * This intentionally duplicates btrfs_util_is_subvolume_fd() instead of opening
  36  * a file descriptor and calling it, because fstat() and fstatfs() don't accept
  37  * file descriptors opened with O_PATH on old kernels (before v3.6 and before
  38  * v3.12, respectively), but stat() and statfs() can be called on a path that
  39  * the user doesn't have read or write permissions to.
  40  */
  41 PUBLIC enum btrfs_util_error btrfs_util_is_subvolume(const char *path)
  42 {
  43         struct statfs sfs;
  44         struct stat st;
  45         int ret;
  46
  47         ret = statfs(path, &sfs);
  48         if (ret == -1)
  49                 return BTRFS_UTIL_ERROR_STATFS_FAILED;
  50
  51         if (sfs.f_type != BTRFS_SUPER_MAGIC) {
  52                 errno = EINVAL;
  53                 return BTRFS_UTIL_ERROR_NOT_BTRFS;
  54         }
  55
  56         ret = stat(path, &st);
  57         if (ret == -1)
  58                 return BTRFS_UTIL_ERROR_STAT_FAILED;
  59
  60         if (st.st_ino != BTRFS_FIRST_FREE_OBJECTID || !S_ISDIR(st.st_mode)) {
  61                 errno = EINVAL;
  62                 return BTRFS_UTIL_ERROR_NOT_SUBVOLUME;
  63         }
  64
  65         return BTRFS_UTIL_OK;
  66 }
  67
  68 PUBLIC enum btrfs_util_error btrfs_util_is_subvolume_fd(int fd)
  69 {
  70         struct statfs sfs;
  71         struct stat st;
  72         int ret;
  73
  74         ret = fstatfs(fd, &sfs);
  75         if (ret == -1)
  76                 return BTRFS_UTIL_ERROR_STATFS_FAILED;
  77
  78         if (sfs.f_type != BTRFS_SUPER_MAGIC) {
  79                 errno = EINVAL;
  80                 return BTRFS_UTIL_ERROR_NOT_BTRFS;
  81         }
  82
  83         ret = fstat(fd, &st);
  84         if (ret == -1)
  85                 return BTRFS_UTIL_ERROR_STAT_FAILED;
  86
  87         if (st.st_ino != BTRFS_FIRST_FREE_OBJECTID || !S_ISDIR(st.st_mode)) {
  88                 errno = EINVAL;
  89                 return BTRFS_UTIL_ERROR_NOT_SUBVOLUME;
  90         }
  91
  92         return BTRFS_UTIL_OK;
  93 }
  94
  95 PUBLIC enum btrfs_util_error btrfs_util_subvolume_id(const char *path,
  96                                                      uint64_t *id_ret)
  97 {
  98         enum btrfs_util_error err;
  99         int fd;
 100
 101         fd = open(path, O_RDONLY);
 102         if (fd == -1)
 103                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 104
 105         err = btrfs_util_subvolume_id_fd(fd, id_ret);
 106         SAVE_ERRNO_AND_CLOSE(fd);
 107         return err;
 108 }
 109
 110 PUBLIC enum btrfs_util_error btrfs_util_subvolume_id_fd(int fd,
 111                                                         uint64_t *id_ret)
 112 {
 113         struct btrfs_ioctl_ino_lookup_args args = {
 114                 .treeid = 0,
 115                 .objectid = BTRFS_FIRST_FREE_OBJECTID,
 116         };
 117         int ret;
 118
 119         ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
 120         if (ret == -1) {
 121                 close(fd);
 122                 return BTRFS_UTIL_ERROR_INO_LOOKUP_FAILED;
 123         }
 124
 125         *id_ret = args.treeid;
 126
 127         return BTRFS_UTIL_OK;
 128 }
 129
 130 PUBLIC enum btrfs_util_error btrfs_util_subvolume_path(const char *path,
 131                                                        uint64_t id,
 132                                                        char **path_ret)
 133 {
 134         enum btrfs_util_error err;
 135         int fd;
 136
 137         fd = open(path, O_RDONLY);
 138         if (fd == -1)
 139                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 140
 141         err = btrfs_util_subvolume_path_fd(fd, id, path_ret);
 142         SAVE_ERRNO_AND_CLOSE(fd);
 143         return err;
 144 }
 145
 146 PUBLIC enum btrfs_util_error btrfs_util_subvolume_path_fd(int fd, uint64_t id,
 147                                                           char **path_ret)
 148 {
 149         char *path, *p;
 150         size_t capacity = 4096;
 151
 152         if (id == 0) {
 153                 enum btrfs_util_error err;
 154
 155                 err = btrfs_util_is_subvolume_fd(fd);
 156                 if (err)
 157                         return err;
 158
 159                 err = btrfs_util_subvolume_id_fd(fd, &id);
 160                 if (err)
 161                         return err;
 162         }
 163
 164         path = malloc(capacity);
 165         if (!path)
 166                 return BTRFS_UTIL_ERROR_NO_MEMORY;
 167         p = path + capacity - 1;
 168         p[0] = '\0';
 169
 170         while (id != BTRFS_FS_TREE_OBJECTID) {
 171                 struct btrfs_ioctl_search_args search = {
 172                         .key = {
 173                                 .tree_id = BTRFS_ROOT_TREE_OBJECTID,
 174                                 .min_objectid = id,
 175                                 .max_objectid = id,
 176                                 .min_type = BTRFS_ROOT_BACKREF_KEY,
 177                                 .max_type = BTRFS_ROOT_BACKREF_KEY,
 178                                 .min_offset = 0,
 179                                 .max_offset = UINT64_MAX,
 180                                 .min_transid = 0,
 181                                 .max_transid = UINT64_MAX,
 182                                 .nr_items = 1,
 183                         },
 184                 };
 185                 struct btrfs_ioctl_ino_lookup_args lookup;
 186                 const struct btrfs_ioctl_search_header *header;
 187                 const struct btrfs_root_ref *ref;
 188                 const char *name;
 189                 uint16_t name_len;
 190                 size_t lookup_len;
 191                 size_t total_len;
 192                 int ret;
 193
 194                 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search);
 195                 if (ret == -1) {
 196                         free(path);
 197                         return BTRFS_UTIL_ERROR_SEARCH_FAILED;
 198                 }
 199
 200                 if (search.key.nr_items == 0) {
 201                         free(path);
 202                         errno = ENOENT;
 203                         return BTRFS_UTIL_ERROR_SUBVOLUME_NOT_FOUND;
 204                 }
 205
 206                 header = (struct btrfs_ioctl_search_header *)search.buf;
 207                 ref = (struct btrfs_root_ref *)(header + 1);
 208                 name = (char *)(ref + 1);
 209                 name_len = le16_to_cpu(ref->name_len);
 210
 211                 id = header->offset;
 212
 213                 lookup.treeid = id;
 214                 lookup.objectid = le64_to_cpu(ref->dirid);
 215                 ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &lookup);
 216                 if (ret == -1) {
 217                         free(path);
 218                         return BTRFS_UTIL_ERROR_SEARCH_FAILED;
 219                 }
 220                 lookup_len = strlen(lookup.name);
 221
 222                 total_len = name_len + lookup_len + (id != BTRFS_FS_TREE_OBJECTID);
 223                 if (p - total_len < path) {
 224                         char *new_path, *new_p;
 225                         size_t new_capacity = capacity * 2;
 226
 227                         new_path = malloc(new_capacity);
 228                         if (!new_path) {
 229                                 free(path);
 230                                 return BTRFS_UTIL_ERROR_NO_MEMORY;
 231                         }
 232                         new_p = new_path + new_capacity - (path + capacity - p);
 233                         memcpy(new_p, p, path + capacity - p);
 234                         free(path);
 235                         path = new_path;
 236                         p = new_p;
 237                         capacity = new_capacity;
 238                 }
 239                 p -= name_len;
 240                 memcpy(p, name, name_len);
 241                 p -= lookup_len;
 242                 memcpy(p, lookup.name, lookup_len);
 243                 if (id != BTRFS_FS_TREE_OBJECTID)
 244                         *--p = '/';
 245         }
 246
 247         if (p != path)
 248                 memmove(path, p, path + capacity - p);
 249
 250         *path_ret = path;
 251
 252         return BTRFS_UTIL_OK;
 253 }
 254
 255 static void copy_timespec(struct timespec *timespec,
 256                           const struct btrfs_timespec *btrfs_timespec)
 257 {
 258         timespec->tv_sec = le64_to_cpu(btrfs_timespec->sec);
 259         timespec->tv_nsec = le32_to_cpu(btrfs_timespec->nsec);
 260 }
 261
 262 static void copy_root_item(struct btrfs_util_subvolume_info *subvol,
 263                            const struct btrfs_root_item *root)
 264 {
 265         subvol->flags = le64_to_cpu(root->flags);
 266         memcpy(subvol->uuid, root->uuid, sizeof(subvol->uuid));
 267         memcpy(subvol->parent_uuid, root->parent_uuid,
 268                sizeof(subvol->parent_uuid));
 269         memcpy(subvol->received_uuid, root->received_uuid,
 270                sizeof(subvol->received_uuid));
 271         subvol->generation = le64_to_cpu(root->generation);
 272         subvol->ctransid = le64_to_cpu(root->ctransid);
 273         subvol->otransid = le64_to_cpu(root->otransid);
 274         subvol->stransid = le64_to_cpu(root->stransid);
 275         subvol->rtransid = le64_to_cpu(root->rtransid);
 276         copy_timespec(&subvol->ctime, &root->ctime);
 277         copy_timespec(&subvol->otime, &root->otime);
 278         copy_timespec(&subvol->stime, &root->stime);
 279         copy_timespec(&subvol->rtime, &root->rtime);
 280 }
 281
 282 PUBLIC enum btrfs_util_error btrfs_util_subvolume_info(const char *path,
 283                                                        uint64_t id,
 284                                                        struct btrfs_util_subvolume_info *subvol)
 285 {
 286         enum btrfs_util_error err;
 287         int fd;
 288
 289         fd = open(path, O_RDONLY);
 290         if (fd == -1)
 291                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 292
 293         err = btrfs_util_subvolume_info_fd(fd, id, subvol);
 294         SAVE_ERRNO_AND_CLOSE(fd);
 295         return err;
 296 }
 297
 298 PUBLIC enum btrfs_util_error btrfs_util_subvolume_info_fd(int fd, uint64_t id,
 299                                                           struct btrfs_util_subvolume_info *subvol)
 300 {
 301         struct btrfs_ioctl_search_args search = {
 302                 .key = {
 303                         .tree_id = BTRFS_ROOT_TREE_OBJECTID,
 304                         .min_type = BTRFS_ROOT_ITEM_KEY,
 305                         .max_type = BTRFS_ROOT_BACKREF_KEY,
 306                         .min_offset = 0,
 307                         .max_offset = UINT64_MAX,
 308                         .min_transid = 0,
 309                         .max_transid = UINT64_MAX,
 310                         .nr_items = 0,
 311                 },
 312         };
 313         enum btrfs_util_error err;
 314         size_t items_pos = 0, buf_off = 0;
 315         bool need_root_item = true, need_root_backref = true;
 316         int ret;
 317
 318         if (id == 0) {
 319                 err = btrfs_util_is_subvolume_fd(fd);
 320                 if (err)
 321                         return err;
 322
 323                 err = btrfs_util_subvolume_id_fd(fd, &id);
 324                 if (err)
 325                         return err;
 326         }
 327
 328         if ((id < BTRFS_FIRST_FREE_OBJECTID && id != BTRFS_FS_TREE_OBJECTID) ||
 329             id > BTRFS_LAST_FREE_OBJECTID) {
 330                 errno = ENOENT;
 331                 return BTRFS_UTIL_ERROR_SUBVOLUME_NOT_FOUND;
 332         }
 333
 334         search.key.min_objectid = search.key.max_objectid = id;
 335
 336         if (subvol) {
 337                 subvol->id = id;
 338                 subvol->parent_id = 0;
 339                 subvol->dir_id = 0;
 340                 if (id == BTRFS_FS_TREE_OBJECTID)
 341                         need_root_backref = false;
 342         } else {
 343                 /*
 344                  * We only need the backref for filling in the subvolume info.
 345                  */
 346                 need_root_backref = false;
 347         }
 348
 349         /* Don't bother searching for the backref if we don't need it. */
 350         if (!need_root_backref)
 351                 search.key.max_type = BTRFS_ROOT_ITEM_KEY;
 352
 353         while (need_root_item || need_root_backref) {
 354                 const struct btrfs_ioctl_search_header *header;
 355
 356                 if (items_pos >= search.key.nr_items) {
 357                         search.key.nr_items = 4096;
 358                         ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search);
 359                         if (ret == -1)
 360                                 return BTRFS_UTIL_ERROR_SEARCH_FAILED;
 361                         items_pos = 0;
 362                         buf_off = 0;
 363
 364                         if (search.key.nr_items == 0) {
 365                                 if (need_root_item) {
 366                                         errno = ENOENT;
 367                                         return BTRFS_UTIL_ERROR_SUBVOLUME_NOT_FOUND;
 368                                 } else {
 369                                         break;
 370                                 }
 371                         }
 372                 }
 373
 374                 header = (struct btrfs_ioctl_search_header *)(search.buf + buf_off);
 375                 if (header->type == BTRFS_ROOT_ITEM_KEY) {
 376                         if (subvol) {
 377                                 const struct btrfs_root_item *root;
 378
 379                                 root = (const struct btrfs_root_item *)(header + 1);
 380                                 copy_root_item(subvol, root);
 381                         }
 382                         need_root_item = false;
 383                         search.key.min_type = BTRFS_ROOT_BACKREF_KEY;
 384                 } else if (header->type == BTRFS_ROOT_BACKREF_KEY) {
 385                         if (subvol) {
 386                                 const struct btrfs_root_ref *ref;
 387
 388                                 ref = (const struct btrfs_root_ref *)(header + 1);
 389                                 subvol->parent_id = header->offset;
 390                                 subvol->dir_id = le64_to_cpu(ref->dirid);
 391                         }
 392                         need_root_backref = false;
 393                         search.key.min_type = UINT32_MAX;
 394                 }
 395
 396                 items_pos++;
 397                 buf_off += sizeof(*header) + header->len;
 398         }
 399
 400         return BTRFS_UTIL_OK;
 401 }
 402
 403 PUBLIC enum btrfs_util_error btrfs_util_get_subvolume_read_only_fd(int fd,
 404                                                                    bool *read_only_ret)
 405 {
 406         uint64_t flags;
 407         int ret;
 408
 409         ret = ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags);
 410         if (ret == -1)
 411                 return BTRFS_UTIL_ERROR_SUBVOL_GETFLAGS_FAILED;
 412
 413         *read_only_ret = flags & BTRFS_SUBVOL_RDONLY;
 414         return BTRFS_UTIL_OK;
 415 }
 416
 417 PUBLIC enum btrfs_util_error btrfs_util_get_subvolume_read_only(const char *path,
 418                                                                 bool *ret)
 419 {
 420         enum btrfs_util_error err;
 421         int fd;
 422
 423         fd = open(path, O_RDONLY);
 424         if (fd == -1)
 425                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 426
 427         err = btrfs_util_get_subvolume_read_only_fd(fd, ret);
 428         SAVE_ERRNO_AND_CLOSE(fd);
 429         return err;
 430 }
 431
 432 PUBLIC enum btrfs_util_error btrfs_util_set_subvolume_read_only(const char *path,
 433                                                                 bool read_only)
 434 {
 435         enum btrfs_util_error err;
 436         int fd;
 437
 438         fd = open(path, O_RDONLY);
 439         if (fd == -1)
 440                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 441
 442         err = btrfs_util_set_subvolume_read_only_fd(fd, read_only);
 443         SAVE_ERRNO_AND_CLOSE(fd);
 444         return err;
 445 }
 446
 447 PUBLIC enum btrfs_util_error btrfs_util_set_subvolume_read_only_fd(int fd,
 448                                                                    bool read_only)
 449 {
 450         uint64_t flags;
 451         int ret;
 452
 453         ret = ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags);
 454         if (ret == -1)
 455                 return BTRFS_UTIL_ERROR_SUBVOL_GETFLAGS_FAILED;
 456
 457         if (read_only)
 458                 flags |= BTRFS_SUBVOL_RDONLY;
 459         else
 460                 flags &= ~BTRFS_SUBVOL_RDONLY;
 461
 462         ret = ioctl(fd, BTRFS_IOC_SUBVOL_SETFLAGS, &flags);
 463         if (ret == -1)
 464                 return BTRFS_UTIL_ERROR_SUBVOL_SETFLAGS_FAILED;
 465
 466         return BTRFS_UTIL_OK;
 467 }
 468
 469 PUBLIC enum btrfs_util_error btrfs_util_get_default_subvolume(const char *path,
 470                                                               uint64_t *id_ret)
 471 {
 472         enum btrfs_util_error err;
 473         int fd;
 474
 475         fd = open(path, O_RDONLY);
 476         if (fd == -1)
 477                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 478
 479         err = btrfs_util_get_default_subvolume_fd(fd, id_ret);
 480         SAVE_ERRNO_AND_CLOSE(fd);
 481         return err;
 482 }
 483
 484 PUBLIC enum btrfs_util_error btrfs_util_get_default_subvolume_fd(int fd,
 485                                                                  uint64_t *id_ret)
 486 {
 487         struct btrfs_ioctl_search_args search = {
 488                 .key = {
 489                         .tree_id = BTRFS_ROOT_TREE_OBJECTID,
 490                         .min_objectid = BTRFS_ROOT_TREE_DIR_OBJECTID,
 491                         .max_objectid = BTRFS_ROOT_TREE_DIR_OBJECTID,
 492                         .min_type = BTRFS_DIR_ITEM_KEY,
 493                         .max_type = BTRFS_DIR_ITEM_KEY,
 494                         .min_offset = 0,
 495                         .max_offset = UINT64_MAX,
 496                         .min_transid = 0,
 497                         .max_transid = UINT64_MAX,
 498                         .nr_items = 0,
 499                 },
 500         };
 501         size_t items_pos = 0, buf_off = 0;
 502         int ret;
 503
 504         for (;;) {
 505                 const struct btrfs_ioctl_search_header *header;
 506
 507                 if (items_pos >= search.key.nr_items) {
 508                         search.key.nr_items = 4096;
 509                         ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search);
 510                         if (ret == -1)
 511                                 return BTRFS_UTIL_ERROR_SEARCH_FAILED;
 512                         items_pos = 0;
 513                         buf_off = 0;
 514
 515                         if (search.key.nr_items == 0) {
 516                                 errno = ENOENT;
 517                                 return BTRFS_UTIL_ERROR_SUBVOLUME_NOT_FOUND;
 518                         }
 519                 }
 520
 521                 header = (struct btrfs_ioctl_search_header *)(search.buf + buf_off);
 522                 if (header->type == BTRFS_DIR_ITEM_KEY) {
 523                         const struct btrfs_dir_item *dir;
 524                         const char *name;
 525                         uint16_t name_len;
 526
 527                         dir = (struct btrfs_dir_item *)(header + 1);
 528                         name = (const char *)(dir + 1);
 529                         name_len = le16_to_cpu(dir->name_len);
 530                         if (strncmp(name, "default", name_len) == 0) {
 531                                 *id_ret = le64_to_cpu(dir->location.objectid);
 532                                 break;
 533                         }
 534                 }
 535
 536                 items_pos++;
 537                 buf_off += sizeof(*header) + header->len;
 538                 search.key.min_offset = header->offset + 1;
 539         }
 540
 541         return BTRFS_UTIL_OK;
 542 }
 543
 544 PUBLIC enum btrfs_util_error btrfs_util_set_default_subvolume(const char *path,
 545                                                               uint64_t id)
 546 {
 547         enum btrfs_util_error err;
 548         int fd;
 549
 550         fd = open(path, O_RDONLY);
 551         if (fd == -1)
 552                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 553
 554         err = btrfs_util_set_default_subvolume_fd(fd, id);
 555         SAVE_ERRNO_AND_CLOSE(fd);
 556         return err;
 557 }
 558
 559 PUBLIC enum btrfs_util_error btrfs_util_set_default_subvolume_fd(int fd,
 560                                                                  uint64_t id)
 561 {
 562         enum btrfs_util_error err;
 563         int ret;
 564
 565         if (id == 0) {
 566                 err = btrfs_util_is_subvolume_fd(fd);
 567                 if (err)
 568                         return err;
 569
 570                 err = btrfs_util_subvolume_id_fd(fd, &id);
 571                 if (err)
 572                         return err;
 573         }
 574
 575         ret = ioctl(fd, BTRFS_IOC_DEFAULT_SUBVOL, &id);
 576         if (ret == -1)
 577                 return BTRFS_UTIL_ERROR_DEFAULT_SUBVOL_FAILED;
 578
 579         return BTRFS_UTIL_OK;
 580 }
 581
 582 static enum btrfs_util_error openat_parent_and_name(int dirfd, const char *path,
 583                                                     char *name, size_t name_len,
 584                                                     int *fd)
 585 {
 586         char *tmp_path, *slash, *dirname, *basename;
 587         size_t len;
 588
 589         /* Ignore trailing slashes. */
 590         len = strlen(path);
 591         while (len > 1 && path[len - 1] == '/')
 592                 len--;
 593
 594         tmp_path = malloc(len + 1);
 595         if (!tmp_path)
 596                 return BTRFS_UTIL_ERROR_NO_MEMORY;
 597         memcpy(tmp_path, path, len);
 598         tmp_path[len] = '\0';
 599
 600         slash = memrchr(tmp_path, '/', len);
 601         if (slash == tmp_path) {
 602                 dirname = "/";
 603                 basename = tmp_path + 1;
 604         } else if (slash) {
 605                 *slash = '\0';
 606                 dirname = tmp_path;
 607                 basename = slash + 1;
 608         } else {
 609                 dirname = ".";
 610                 basename = tmp_path;
 611         }
 612
 613         len = strlen(basename);
 614         if (len >= name_len) {
 615                 free(tmp_path);
 616                 errno = ENAMETOOLONG;
 617                 return BTRFS_UTIL_ERROR_INVALID_ARGUMENT;
 618         }
 619         memcpy(name, basename, len);
 620         name[len] = '\0';
 621
 622         *fd = openat(dirfd, dirname, O_RDONLY | O_DIRECTORY);
 623         if (*fd == -1) {
 624                 free(tmp_path);
 625                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 626         }
 627
 628         free(tmp_path);
 629         return BTRFS_UTIL_OK;
 630 }
 631
 632 PUBLIC enum btrfs_util_error btrfs_util_create_subvolume(const char *path,
 633                                                          int flags,
 634                                                          uint64_t *async_transid,
 635                                                          struct btrfs_util_qgroup_inherit *qgroup_inherit)
 636 {
 637         char name[BTRFS_SUBVOL_NAME_MAX + 1];
 638         enum btrfs_util_error err;
 639         int parent_fd;
 640
 641         err = openat_parent_and_name(AT_FDCWD, path, name, sizeof(name),
 642                                      &parent_fd);
 643         if (err)
 644                 return err;
 645
 646         err = btrfs_util_create_subvolume_fd(parent_fd, name, flags,
 647                                             async_transid, qgroup_inherit);
 648         SAVE_ERRNO_AND_CLOSE(parent_fd);
 649         return err;
 650 }
 651
 652 PUBLIC enum btrfs_util_error btrfs_util_create_subvolume_fd(int parent_fd,
 653                                                             const char *name,
 654                                                             int flags,
 655                                                             uint64_t *async_transid,
 656                                                             struct btrfs_util_qgroup_inherit *qgroup_inherit)
 657 {
 658         struct btrfs_ioctl_vol_args_v2 args = {};
 659         size_t len;
 660         int ret;
 661
 662         if (flags) {
 663                 errno = EINVAL;
 664                 return BTRFS_UTIL_ERROR_INVALID_ARGUMENT;
 665         }
 666
 667         if (async_transid)
 668                 args.flags |= BTRFS_SUBVOL_CREATE_ASYNC;
 669         if (qgroup_inherit) {
 670                 args.flags |= BTRFS_SUBVOL_QGROUP_INHERIT;
 671                 args.qgroup_inherit = (struct btrfs_qgroup_inherit *)qgroup_inherit;
 672                 args.size = (sizeof(*args.qgroup_inherit) +
 673                              args.qgroup_inherit->num_qgroups *
 674                              sizeof(args.qgroup_inherit->qgroups[0]));
 675         }
 676
 677         len = strlen(name);
 678         if (len >= sizeof(args.name)) {
 679                 errno = ENAMETOOLONG;
 680                 return BTRFS_UTIL_ERROR_INVALID_ARGUMENT;
 681         }
 682         memcpy(args.name, name, len);
 683         args.name[len] = '\0';
 684
 685         ret = ioctl(parent_fd, BTRFS_IOC_SUBVOL_CREATE_V2, &args);
 686         if (ret == -1)
 687                 return BTRFS_UTIL_ERROR_SUBVOL_CREATE_FAILED;
 688
 689         if (async_transid)
 690                 *async_transid = args.transid;
 691
 692         return BTRFS_UTIL_OK;
 693 }
 694
 695 #define BTRFS_UTIL_SUBVOLUME_ITERATOR_CLOSE_FD (1 << 30)
 696
 697 struct search_stack_entry {
 698         struct btrfs_ioctl_search_args search;
 699         size_t items_pos, buf_off;
 700         size_t path_len;
 701 };
 702
 703 struct btrfs_util_subvolume_iterator {
 704         int fd;
 705         int flags;
 706
 707         struct search_stack_entry *search_stack;
 708         size_t search_stack_len;
 709         size_t search_stack_capacity;
 710
 711         char *cur_path;
 712         size_t cur_path_capacity;
 713 };
 714
 715 static enum btrfs_util_error append_to_search_stack(struct btrfs_util_subvolume_iterator *iter,
 716                                                     uint64_t tree_id,
 717                                                     size_t path_len)
 718 {
 719         struct search_stack_entry *entry;
 720
 721         if (iter->search_stack_len >= iter->search_stack_capacity) {
 722                 size_t new_capacity = iter->search_stack_capacity * 2;
 723                 struct search_stack_entry *new_search_stack;
 724
 725                 new_search_stack = reallocarray(iter->search_stack,
 726                                                 new_capacity,
 727                                                 sizeof(*iter->search_stack));
 728                 if (!new_search_stack)
 729                         return BTRFS_UTIL_ERROR_NO_MEMORY;
 730
 731                 iter->search_stack_capacity = new_capacity;
 732                 iter->search_stack = new_search_stack;
 733         }
 734
 735         entry = &iter->search_stack[iter->search_stack_len++];
 736
 737         memset(&entry->search, 0, sizeof(entry->search));
 738         entry->search.key.tree_id = BTRFS_ROOT_TREE_OBJECTID;
 739         entry->search.key.min_objectid = tree_id;
 740         entry->search.key.max_objectid = tree_id;
 741         entry->search.key.min_type = BTRFS_ROOT_REF_KEY;
 742         entry->search.key.max_type = BTRFS_ROOT_REF_KEY;
 743         entry->search.key.min_offset = 0;
 744         entry->search.key.max_offset = UINT64_MAX;
 745         entry->search.key.min_transid = 0;
 746         entry->search.key.max_transid = UINT64_MAX;
 747         entry->search.key.nr_items = 0;
 748
 749         entry->items_pos = 0;
 750         entry->buf_off = 0;
 751
 752         entry->path_len = path_len;
 753
 754         return BTRFS_UTIL_OK;
 755 }
 756
 757 PUBLIC enum btrfs_util_error btrfs_util_create_subvolume_iterator(const char *path,
 758                                                                   uint64_t top,
 759                                                                   int flags,
 760                                                                   struct btrfs_util_subvolume_iterator **ret)
 761 {
 762         enum btrfs_util_error err;
 763         int fd;
 764
 765         fd = open(path, O_RDONLY);
 766         if (fd == -1)
 767                 return BTRFS_UTIL_ERROR_OPEN_FAILED;
 768
 769         err = btrfs_util_create_subvolume_iterator_fd(fd, top, flags, ret);
 770         if (err)
 771                 SAVE_ERRNO_AND_CLOSE(fd);
 772         else
 773                 (*ret)->flags |= BTRFS_UTIL_SUBVOLUME_ITERATOR_CLOSE_FD;
 774
 775         return err;
 776 }
 777
 778 PUBLIC enum btrfs_util_error btrfs_util_create_subvolume_iterator_fd(int fd,
 779                                                                      uint64_t top,
 780                                                                      int flags,
 781                                                                      struct btrfs_util_subvolume_iterator **ret)
 782 {
 783         struct btrfs_util_subvolume_iterator *iter;
 784         enum btrfs_util_error err;
 785
 786         if (flags & ~BTRFS_UTIL_SUBVOLUME_ITERATOR_MASK) {
 787                 errno = EINVAL;
 788                 return BTRFS_UTIL_ERROR_INVALID_ARGUMENT;
 789         }
 790
 791         if (top == 0) {
 792                 err = btrfs_util_is_subvolume_fd(fd);
 793                 if (err)
 794                         return err;
 795
 796                 err = btrfs_util_subvolume_id_fd(fd, &top);
 797                 if (err)
 798                         return err;
 799         }
 800
 801         iter = malloc(sizeof(*iter));
 802         if (!iter)
 803                 return BTRFS_UTIL_ERROR_NO_MEMORY;
 804
 805         iter->fd = fd;
 806         iter->flags = flags;
 807
 808         iter->search_stack_len = 0;
 809         iter->search_stack_capacity = 4;
 810         iter->search_stack = malloc(sizeof(*iter->search_stack) *
 811                                     iter->search_stack_capacity);
 812         if (!iter->search_stack) {
 813                 err = BTRFS_UTIL_ERROR_NO_MEMORY;
 814                 goto out_iter;
 815         }
 816
 817         iter->cur_path_capacity = 256;
 818         iter->cur_path = malloc(iter->cur_path_capacity);
 819         if (!iter->cur_path) {
 820                 err = BTRFS_UTIL_ERROR_NO_MEMORY;
 821                 goto out_search_stack;
 822         }
 823
 824         err = append_to_search_stack(iter, top, 0);
 825         if (err)
 826                 goto out_cur_path;
 827
 828         *ret = iter;
 829
 830         return BTRFS_UTIL_OK;
 831
 832 out_cur_path:
 833         free(iter->cur_path);
 834 out_search_stack:
 835         free(iter->search_stack);
 836 out_iter:
 837         free(iter);
 838         return err;
 839 }
 840
 841 PUBLIC void btrfs_util_destroy_subvolume_iterator(struct btrfs_util_subvolume_iterator *iter)
 842 {
 843         if (iter) {
 844                 free(iter->cur_path);
 845                 free(iter->search_stack);
 846                 if (iter->flags & BTRFS_UTIL_SUBVOLUME_ITERATOR_CLOSE_FD)
 847                         SAVE_ERRNO_AND_CLOSE(iter->fd);
 848                 free(iter);
 849         }
 850 }
 851
 852 PUBLIC int btrfs_util_subvolume_iterator_fd(const struct btrfs_util_subvolume_iterator *iter)
 853 {
 854         return iter->fd;
 855 }
 856
 857 static struct search_stack_entry *top_search_stack_entry(struct btrfs_util_subvolume_iterator *iter)
 858 {
 859         return &iter->search_stack[iter->search_stack_len - 1];
 860 }
 861
 862 static enum btrfs_util_error build_subvol_path(struct btrfs_util_subvolume_iterator *iter,
 863                                                const struct btrfs_ioctl_search_header *header,
 864                                                const struct btrfs_root_ref *ref,
 865                                                const char *name,
 866                                                size_t *path_len_ret)
 867 {
 868         struct btrfs_ioctl_ino_lookup_args lookup = {
 869                 .treeid = header->objectid,
 870                 .objectid = le64_to_cpu(ref->dirid),
 871         };
 872         struct search_stack_entry *top = top_search_stack_entry(iter);
 873         size_t dir_len, name_len, path_len;
 874         char *p;
 875         int ret;
 876
 877         ret = ioctl(iter->fd, BTRFS_IOC_INO_LOOKUP, &lookup);
 878         if (ret == -1)
 879                 return BTRFS_UTIL_ERROR_INO_LOOKUP_FAILED;
 880
 881         dir_len = strlen(lookup.name);
 882         name_len = le16_to_cpu(ref->name_len);
 883
 884         path_len = top->path_len;
 885         /*
 886          * We need a joining slash if we have a current path and a subdirectory.
 887          */
 888         if (top->path_len && dir_len)
 889                 path_len++;
 890         path_len += dir_len;
 891         /*
 892          * We need another joining slash if we have a current path and a name,
 893          * but not if we have a subdirectory, because the lookup ioctl includes
 894          * a trailing slash.
 895          */
 896         if (top->path_len && !dir_len && name_len)
 897                 path_len++;
 898         path_len += name_len;
 899
 900         if (path_len > iter->cur_path_capacity) {
 901                 char *tmp = realloc(iter->cur_path, path_len);
 902
 903                 if (!tmp)
 904                         return BTRFS_UTIL_ERROR_NO_MEMORY;
 905                 iter->cur_path = tmp;
 906                 iter->cur_path_capacity = path_len;
 907         }
 908
 909         p = iter->cur_path + top->path_len;
 910         if (top->path_len && dir_len)
 911                 *p++ = '/';
 912         memcpy(p, lookup.name, dir_len);
 913         p += dir_len;
 914         if (top->path_len && !dir_len && name_len)
 915                 *p++ = '/';
 916         memcpy(p, name, name_len);
 917         p += name_len;
 918
 919         *path_len_ret = path_len;
 920
 921         return BTRFS_UTIL_OK;
 922 }
 923
 924 PUBLIC enum btrfs_util_error btrfs_util_subvolume_iterator_next(struct btrfs_util_subvolume_iterator *iter,
 925                                                                 char **path_ret,
 926                                                                 uint64_t *id_ret)
 927 {
 928         struct search_stack_entry *top;
 929         const struct btrfs_ioctl_search_header *header;
 930         const struct btrfs_root_ref *ref;
 931         const char *name;
 932         enum btrfs_util_error err;
 933         size_t path_len;
 934         int ret;
 935
 936         for (;;) {
 937                 for (;;) {
 938                         if (iter->search_stack_len == 0)
 939                                 return BTRFS_UTIL_ERROR_STOP_ITERATION;
 940
 941                         top = top_search_stack_entry(iter);
 942                         if (top->items_pos < top->search.key.nr_items) {
 943                                 break;
 944                         } else {
 945                                 top->search.key.nr_items = 4096;
 946                                 ret = ioctl(iter->fd, BTRFS_IOC_TREE_SEARCH, &top->search);
 947                                 if (ret == -1)
 948                                         return BTRFS_UTIL_ERROR_SEARCH_FAILED;
 949                                 top->items_pos = 0;
 950                                 top->buf_off = 0;
 951
 952                                 if (top->search.key.nr_items == 0) {
 953                                         iter->search_stack_len--;
 954                                         if ((iter->flags & BTRFS_UTIL_SUBVOLUME_ITERATOR_POST_ORDER) &&
 955                                             iter->search_stack_len)
 956                                                 goto out;
 957                                 }
 958                         }
 959                 }
 960
 961                 header = (struct btrfs_ioctl_search_header *)(top->search.buf + top->buf_off);
 962
 963                 top->items_pos++;
 964                 top->buf_off += sizeof(*header) + header->len;
 965                 top->search.key.min_offset = header->offset + 1;
 966
 967                 /* This shouldn't happen, but handle it just in case. */
 968                 if (header->type != BTRFS_ROOT_REF_KEY)
 969                         continue;
 970
 971                 ref = (struct btrfs_root_ref *)(header + 1);
 972                 name = (const char *)(ref + 1);
 973                 err = build_subvol_path(iter, header, ref, name, &path_len);
 974                 if (err)
 975                         return err;
 976
 977                 err = append_to_search_stack(iter, header->offset, path_len);
 978                 if (err)
 979                         return err;
 980
 981                 if (!(iter->flags & BTRFS_UTIL_SUBVOLUME_ITERATOR_POST_ORDER)) {
 982                         top = top_search_stack_entry(iter);
 983                         goto out;
 984                 }
 985         }
 986
 987 out:
 988         if (path_ret) {
 989                 *path_ret = malloc(top->path_len + 1);
 990                 if (!*path_ret)
 991                         return BTRFS_UTIL_ERROR_NO_MEMORY;
 992                 memcpy(*path_ret, iter->cur_path, top->path_len);
 993                 (*path_ret)[top->path_len] = '\0';
 994         }
 995         if (id_ret)
 996                 *id_ret = top->search.key.min_objectid;
 997         return BTRFS_UTIL_OK;
 998 }
 999
1000 PUBLIC enum btrfs_util_error btrfs_util_subvolume_iterator_next_info(struct btrfs_util_subvolume_iterator *iter,
1001                                                                      char **path_ret,
1002                                                                      struct btrfs_util_subvolume_info *subvol)
1003 {
1004         enum btrfs_util_error err;
1005         uint64_t id;
1006
1007         err = btrfs_util_subvolume_iterator_next(iter, path_ret, &id);
1008         if (err)
1009                 return err;
1010
1011         return btrfs_util_subvolume_info_fd(iter->fd, id, subvol);
1012 }