../src/basic/btrfs-util.c

Bug Summary

File:	build-scan/../src/basic/btrfs-util.c
Warning:	line 1576, column 42 The right operand of '==' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name btrfs-util.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fdenormal-fp-math=preserve-sign,preserve-sign -ffp-contract=fast -fno-rounding-math -ffast-math -ffinite-math-only -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/12.0.0 -include config.h -I src/basic/libbasic.a.p -I src/basic -I ../src/basic -I src/shared -I ../src/shared -I src/systemd -I ../src/systemd -I src/journal -I ../src/journal -I src/journal-remote -I ../src/journal-remote -I src/nspawn -I ../src/nspawn -I src/resolve -I ../src/resolve -I src/timesync -I ../src/timesync -I ../src/time-wait-sync -I src/login -I ../src/login -I src/udev -I ../src/udev -I src/libudev -I ../src/libudev -I src/core -I ../src/core -I ../src/libsystemd/sd-bus -I ../src/libsystemd/sd-device -I ../src/libsystemd/sd-hwdb -I ../src/libsystemd/sd-id128 -I ../src/libsystemd/sd-netlink -I ../src/libsystemd/sd-network -I src/libsystemd-network -I ../src/libsystemd-network -I . -I .. -I /usr/include/blkid -I /usr/include/libmount -D _FILE_OFFSET_BITS=64 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wwrite-strings -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unused-result -Wno-format-signedness -Wno-error=nonnull -std=gnu99 -fconst-strings -fdebug-compilation-dir /home/mrc0mmand/repos/@redhat-plumbers/systemd-rhel8/build-scan -ferror-limit 19 -fvisibility default -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-07-16-221226-1465241-1 -x c ../src/basic/btrfs-util.c
1/* SPDX-License-Identifier: LGPL-2.1+ */

3#include <errno(*__errno_location ()).h>
4#include <fcntl.h>
5#include <inttypes.h>
6#include <linux1/fs.h>
7#include <linux1/loop.h>
8#include <stddef.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12#include <sys/ioctl.h>
13#include <sys/stat.h>
14#include <sys/statfs.h>
15#include <sys/sysmacros.h>
16#include <unistd.h>

18#if HAVE_LINUX_BTRFS_H1
19#include <linux1/btrfs.h>
20#endif

22#include "alloc-util.h"
23#include "blockdev-util.h"
24#include "btrfs-ctree.h"
25#include "btrfs-util.h"
26#include "chattr-util.h"
27#include "copy.h"
28#include "device-nodes.h"
29#include "fd-util.h"
30#include "fileio.h"
31#include "io-util.h"
32#include "macro.h"
33#include "missing.h"
34#include "path-util.h"
35#include "rm-rf.h"
36#include "smack-util.h"
37#include "sparse-endian.h"
38#include "stat-util.h"
39#include "string-util.h"
40#include "time-util.h"
41#include "util.h"

43/* WARNING: Be careful with file system ioctls! When we get an fd, we
* need to make sure it either refers to only a regular file or
* directory, or that it is located on btrfs, before invoking any
* btrfs ioctls. The ioctl numbers are reused by some device drivers
* (such as DRM), and hence might have bad effects when invoked on
* device nodes (that reference drivers) rather than fds to normal
* files or directories. */

51static int validate_subvolume_name(const char *name) {

      if (!filename_is_valid(name))
              return -EINVAL22;

      if (strlen(name) > BTRFS_SUBVOL_NAME_MAX4039)
              return -E2BIG7;

      return 0;
60}

62static int open_parent(const char *path, int flags) {
      _cleanup_free___attribute__((cleanup(freep))) char *parent = NULL((void*)0);
      int fd;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/btrfs-util.c", 66
, __PRETTY_FUNCTION__); } while (0);

      parent = dirname_malloc(path);
      if (!parent)
              return -ENOMEM12;

      fd = open(parent, flags);
      if (fd < 0)
              return -errno(*__errno_location ());

      return fd;
77}

79static int extract_subvolume_name(const char *path, const char **subvolume) {
      const char *fn;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/btrfs-util.c", 83
, __PRETTY_FUNCTION__); } while (0);
      assert(subvolume)do { if ((__builtin_expect(!!(!(subvolume)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("subvolume"), "../src/basic/btrfs-util.c"
, 84, __PRETTY_FUNCTION__); } while (0);

      fn = basename(path);

      r = validate_subvolume_name(fn);
      if (r < 0)
              return r;

      *subvolume = fn;
      return 0;
94}

96int btrfs_is_filesystem(int fd) {
      struct statfs sfs;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 99, __PRETTY_FUNCTION__); } while (0);

      if (fstatfs(fd, &sfs) < 0)
              return -errno(*__errno_location ());

      return F_TYPE_EQUAL(sfs.f_type, BTRFS_SUPER_MAGIC)(sfs.f_type == (typeof(sfs.f_type)) 0x9123683E);
105}

107int btrfs_is_subvol_fd(int fd) {
      struct stat st;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 110, __PRETTY_FUNCTION__); } while (0);

      /* On btrfs subvolumes always have the inode 256 */

      if (fstat(fd, &st) < 0)
              return -errno(*__errno_location ());

      if (!S_ISDIR(st.st_mode)((((st.st_mode)) & 0170000) == (0040000)) || st.st_ino != 256)
              return 0;

      return btrfs_is_filesystem(fd);
121}

123int btrfs_is_subvol(const char *path) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/btrfs-util.c", 126
, __PRETTY_FUNCTION__); } while (0);

      fd = open(path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_is_subvol_fd(fd);
133}

135int btrfs_subvol_make(const char *path) {
      struct btrfs_ioctl_vol_args args = {};
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;
      const char *subvolume;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/btrfs-util.c", 141
, __PRETTY_FUNCTION__); } while (0);

      r = extract_subvolume_name(path, &subvolume);
      if (r < 0)
              return r;

      fd = open_parent(path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (fd < 0)
              return fd;

      strncpy(args.name, subvolume, sizeof(args.name)-1);

      if (ioctl(fd, BTRFS_IOC_SUBVOL_CREATE(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((14)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args
)))) << ((0 +8)+8))), &args) < 0)
              return -errno(*__errno_location ());

      return 0;
157}

159int btrfs_subvol_set_read_only_fd(int fd, bool_Bool b) {
      uint64_t flags, nflags;
      struct stat st;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 163, __PRETTY_FUNCTION__); } while (0);

      if (fstat(fd, &st) < 0)
              return -errno(*__errno_location ());

      if (!S_ISDIR(st.st_mode)((((st.st_mode)) & 0170000) == (0040000)) || st.st_ino != 256)
              return -EINVAL22;

      if (ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS(((2U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((25)) << 0) | ((((sizeof(__u64)))) << ((0 +8
)+8))), &flags) < 0)
              return -errno(*__errno_location ());

      if (b)
              nflags = flags | BTRFS_SUBVOL_RDONLY(1ULL << 1);
      else
              nflags = flags & ~BTRFS_SUBVOL_RDONLY(1ULL << 1);

      if (flags == nflags)
              return 0;

      if (ioctl(fd, BTRFS_IOC_SUBVOL_SETFLAGS(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((26)) << 0) | ((((sizeof(__u64)))) << ((0 +8
)+8))), &nflags) < 0)
              return -errno(*__errno_location ());

      return 0;
186}

188int btrfs_subvol_set_read_only(const char *path, bool_Bool b) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_subvol_set_read_only_fd(fd, b);
196}

198int btrfs_subvol_get_read_only_fd(int fd) {
      uint64_t flags;
      struct stat st;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 202, __PRETTY_FUNCTION__); } while (0);

      if (fstat(fd, &st) < 0)
              return -errno(*__errno_location ());

      if (!S_ISDIR(st.st_mode)((((st.st_mode)) & 0170000) == (0040000)) || st.st_ino != 256)
              return -EINVAL22;

      if (ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS(((2U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((25)) << 0) | ((((sizeof(__u64)))) << ((0 +8
)+8))), &flags) < 0)
              return -errno(*__errno_location ());

      return !!(flags & BTRFS_SUBVOL_RDONLY(1ULL << 1));
214}

216int btrfs_reflink(int infd, int outfd) {
      int r;

      assert(infd >= 0)do { if ((__builtin_expect(!!(!(infd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("infd >= 0"), "../src/basic/btrfs-util.c"
, 219, __PRETTY_FUNCTION__); } while (0);
      assert(outfd >= 0)do { if ((__builtin_expect(!!(!(outfd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("outfd >= 0"), "../src/basic/btrfs-util.c"
, 220, __PRETTY_FUNCTION__); } while (0);

      /* Make sure we invoke the ioctl on a regular file, so that no device driver accidentally gets it. */

      r = fd_verify_regular(outfd);
      if (r < 0)
              return r;

      if (ioctl(outfd, BTRFS_IOC_CLONE(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((9)) << 0) | ((((sizeof(int)))) << ((0 +8)+8
))), infd) < 0)
              return -errno(*__errno_location ());

      return 0;
232}

234int btrfs_clone_range(int infd, uint64_t in_offset, int outfd, uint64_t out_offset, uint64_t sz) {
      struct btrfs_ioctl_clone_range_args args = {
              .src_fd = infd,
              .src_offset = in_offset,
              .src_length = sz,
              .dest_offset = out_offset,
      };
      int r;

      assert(infd >= 0)do { if ((__builtin_expect(!!(!(infd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("infd >= 0"), "../src/basic/btrfs-util.c"
, 243, __PRETTY_FUNCTION__); } while (0);
      assert(outfd >= 0)do { if ((__builtin_expect(!!(!(outfd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("outfd >= 0"), "../src/basic/btrfs-util.c"
, 244, __PRETTY_FUNCTION__); } while (0);
      assert(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/basic/btrfs-util.c"
, 245, __PRETTY_FUNCTION__); } while (0);

      r = fd_verify_regular(outfd);
      if (r < 0)
              return r;

      if (ioctl(outfd, BTRFS_IOC_CLONE_RANGE(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((13)) << 0) | ((((sizeof(struct btrfs_ioctl_clone_range_args
)))) << ((0 +8)+8))), &args) < 0)
              return -errno(*__errno_location ());

      return 0;
255}

257int btrfs_get_block_device_fd(int fd, dev_t *dev) {
      struct btrfs_ioctl_fs_info_args fsi = {};
      uint64_t id;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 262, __PRETTY_FUNCTION__); } while (0);
      assert(dev)do { if ((__builtin_expect(!!(!(dev)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("dev"), "../src/basic/btrfs-util.c", 263
, __PRETTY_FUNCTION__); } while (0);

      r = btrfs_is_filesystem(fd);
      if (r < 0)
              return r;
      if (!r)
              return -ENOTTY25;

      if (ioctl(fd, BTRFS_IOC_FS_INFO(((2U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((31)) << 0) | ((((sizeof(struct btrfs_ioctl_fs_info_args
)))) << ((0 +8)+8))), &fsi) < 0)
              return -errno(*__errno_location ());

      /* We won't do this for btrfs RAID */
      if (fsi.num_devices != 1) {
              *dev = 0;
              return 0;
      }

      for (id = 1; id <= fsi.max_id; id++) {
              struct btrfs_ioctl_dev_info_args di = {
                      .devid = id,
              };
              struct stat st;

              if (ioctl(fd, BTRFS_IOC_DEV_INFO(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((30)) << 0) | ((((sizeof(struct btrfs_ioctl_dev_info_args
)))) << ((0 +8)+8))), &di) < 0) {
                      if (errno(*__errno_location ()) == ENODEV19)
                              continue;

                      return -errno(*__errno_location ());
              }

              if (stat((char*) di.path, &st) < 0)
                      return -errno(*__errno_location ());

              if (!S_ISBLK(st.st_mode)((((st.st_mode)) & 0170000) == (0060000)))
                      return -ENODEV19;

              if (major(st.st_rdev)gnu_dev_major (st.st_rdev) == 0)
                      return -ENODEV19;

              *dev = st.st_rdev;
              return 1;
      }

      return -ENODEV19;
307}

309int btrfs_get_block_device(const char *path, dev_t *dev) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/btrfs-util.c", 312
, __PRETTY_FUNCTION__); } while (0);
      assert(dev)do { if ((__builtin_expect(!!(!(dev)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("dev"), "../src/basic/btrfs-util.c", 313
, __PRETTY_FUNCTION__); } while (0);

      fd = open(path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_get_block_device_fd(fd, dev);
320}

322int btrfs_subvol_get_id_fd(int fd, uint64_t *ret) {
      struct btrfs_ioctl_ino_lookup_args args = {
              .objectid = BTRFS_FIRST_FREE_OBJECTID256
      };
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 328, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 329
, __PRETTY_FUNCTION__); } while (0);

      r = btrfs_is_filesystem(fd);
      if (r < 0)
              return r;
      if (!r)
              return -ENOTTY25;

      if (ioctl(fd, BTRFS_IOC_INO_LOOKUP(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((18)) << 0) | ((((sizeof(struct btrfs_ioctl_ino_lookup_args
)))) << ((0 +8)+8))), &args) < 0)
              return -errno(*__errno_location ());

      *ret = args.treeid;
      return 0;
342}

344int btrfs_subvol_get_id(int fd, const char *subvol, uint64_t *ret) {
      _cleanup_close___attribute__((cleanup(closep))) int subvol_fd = -1;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 347, __PRETTY_FUNCTION__); } while (0);
37
←
Taking false branch→
38
←
Loop condition is false.  Exiting loop→
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 348
, __PRETTY_FUNCTION__); } while (0);
39
←
Taking false branch→
40
←
Loop condition is false.  Exiting loop→

      subvol_fd = openat(fd, subvol, O_RDONLY00|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (subvol_fd < 0)
41
←
Assuming 'subvol_fd' is < 0→
42
←
Taking true branch→
              return -errno(*__errno_location ());
43
←
Returning without writing to '*ret'→

      return btrfs_subvol_get_id_fd(subvol_fd, ret);
355}

357static bool_Bool btrfs_ioctl_search_args_inc(struct btrfs_ioctl_search_args *args) {
      assert(args)do { if ((__builtin_expect(!!(!(args)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("args"), "../src/basic/btrfs-util.c", 358
, __PRETTY_FUNCTION__); } while (0);

      /* the objectid, type, offset together make up the btrfs key,
       * which is considered a single 136byte integer when
       * comparing. This call increases the counter by one, dealing
       * with the overflow between the overflows */

      if (args->key.min_offset < (uint64_t) -1) {
              args->key.min_offset++;
              return true1;
      }

      if (args->key.min_type < (uint8_t) -1) {
              args->key.min_type++;
              args->key.min_offset = 0;
              return true1;
      }

      if (args->key.min_objectid < (uint64_t) -1) {
              args->key.min_objectid++;
              args->key.min_offset = 0;
              args->key.min_type = 0;
              return true1;
      }

      return 0;
384}

386static void btrfs_ioctl_search_args_set(struct btrfs_ioctl_search_args *args, const struct btrfs_ioctl_search_header *h) {
      assert(args)do { if ((__builtin_expect(!!(!(args)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("args"), "../src/basic/btrfs-util.c", 387
, __PRETTY_FUNCTION__); } while (0);
      assert(h)do { if ((__builtin_expect(!!(!(h)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("h"), "../src/basic/btrfs-util.c", 388, __PRETTY_FUNCTION__
); } while (0);

      args->key.min_objectid = h->objectid;
      args->key.min_type = h->type;
      args->key.min_offset = h->offset;
393}

395static int btrfs_ioctl_search_args_compare(const struct btrfs_ioctl_search_args *args) {
      assert(args)do { if ((__builtin_expect(!!(!(args)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("args"), "../src/basic/btrfs-util.c", 396
, __PRETTY_FUNCTION__); } while (0);

      /* Compare min and max */

      if (args->key.min_objectid < args->key.max_objectid)
              return -1;
      if (args->key.min_objectid > args->key.max_objectid)
              return 1;

      if (args->key.min_type < args->key.max_type)
              return -1;
      if (args->key.min_type > args->key.max_type)
              return 1;

      if (args->key.min_offset < args->key.max_offset)
              return -1;
      if (args->key.min_offset > args->key.max_offset)
              return 1;

      return 0;
416}

418#define FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len))                  \
      for ((i) = 0,                                                   \
           (sh) = (const struct btrfs_ioctl_search_header*) (args).buf; \
           (i) < (args).key.nr_items;                                 \
           (i)++,                                                     \
           (sh) = (const struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof(struct btrfs_ioctl_search_header) + (sh)->len))

425#define BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)))                              \
      ((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header)))

428int btrfs_subvol_get_info_fd(int fd, uint64_t subvol_id, BtrfsSubvolInfo *ret) {
      struct btrfs_ioctl_search_args args = {
              /* Tree of tree roots */
              .key.tree_id = BTRFS_ROOT_TREE_OBJECTID1,

              /* Look precisely for the subvolume items */
              .key.min_type = BTRFS_ROOT_ITEM_KEY132,
              .key.max_type = BTRFS_ROOT_ITEM_KEY132,

              .key.min_offset = 0,
              .key.max_offset = (uint64_t) -1,

              /* No restrictions on the other components */
              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };

      bool_Bool found = false0;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 448, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 449
, __PRETTY_FUNCTION__); } while (0);

      if (subvol_id == 0) {
              r = btrfs_subvol_get_id_fd(fd, &subvol_id);
              if (r < 0)
                      return r;
      } else {
              r = btrfs_is_filesystem(fd);
              if (r < 0)
                      return r;
              if (!r)
                      return -ENOTTY25;
      }

      args.key.min_objectid = args.key.max_objectid = subvol_id;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0)
                      return -errno(*__errno_location ());

              if (args.key.nr_items <= 0)
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {

                      const struct btrfs_root_item *ri;

                      /* Make sure we start the next search at least from this entry */
                      btrfs_ioctl_search_args_set(&args, sh);

                      if (sh->objectid != subvol_id)
                              continue;
                      if (sh->type != BTRFS_ROOT_ITEM_KEY132)
                              continue;

                      /* Older versions of the struct lacked the otime setting */
                      if (sh->len < offsetof(struct btrfs_root_item, otime)__builtin_offsetof(struct btrfs_root_item, otime) + sizeof(struct btrfs_timespec))
                              continue;

                      ri = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)));

                      ret->otime = (usec_t) le64toh(ri->otime.sec) * USEC_PER_SEC((usec_t) 1000000ULL) +
                              (usec_t) le32toh(ri->otime.nsec) / NSEC_PER_USEC((nsec_t) 1000ULL);

                      ret->subvol_id = subvol_id;
                      ret->read_only = le64toh(ri->flags) & BTRFS_ROOT_SUBVOL_RDONLY(1ULL << 0);

                      assert_cc(sizeof(ri->uuid) == sizeof(ret->uuid))GCC diagnostic push
; GCC diagnostic ignored "-Wdeclaration-after-statement"

; struct _assert_struct_6 { char x[(sizeof(ri->uuid) == sizeof
(ret->uuid)) ? 0 : -1]; }; GCC diagnostic pop
;
                      memcpy(&ret->uuid, ri->uuid, sizeof(ret->uuid));
                      memcpy(&ret->parent_uuid, ri->parent_uuid, sizeof(ret->parent_uuid));

                      found = true1;
                      goto finish;
              }

              /* Increase search key by one, to read the next item, if we can. */
              if (!btrfs_ioctl_search_args_inc(&args))
                      break;
      }

513finish:
      if (!found)
              return -ENODATA61;

      return 0;
518}

520int btrfs_qgroup_get_quota_fd(int fd, uint64_t qgroupid, BtrfsQuotaInfo *ret) {

      struct btrfs_ioctl_search_args args = {
              /* Tree of quota items */
              .key.tree_id = BTRFS_QUOTA_TREE_OBJECTID8ULL,

              /* The object ID is always 0 */
              .key.min_objectid = 0,
              .key.max_objectid = 0,

              /* Look precisely for the quota items */
              .key.min_type = BTRFS_QGROUP_STATUS_KEY240,
              .key.max_type = BTRFS_QGROUP_LIMIT_KEY244,

              /* No restrictions on the other components */
              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };

      bool_Bool found_info = false0, found_limit = false0;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 542, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 543
, __PRETTY_FUNCTION__); } while (0);

      if (qgroupid == 0) {
              r = btrfs_subvol_get_id_fd(fd, &qgroupid);
              if (r < 0)
                      return r;
      } else {
              r = btrfs_is_filesystem(fd);
              if (r < 0)
                      return r;
              if (!r)
                      return -ENOTTY25;
      }

      args.key.min_offset = args.key.max_offset = qgroupid;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0) {
                      if (errno(*__errno_location ()) == ENOENT2) /* quota tree is missing: quota disabled */
                              break;

                      return -errno(*__errno_location ());
              }

              if (args.key.nr_items <= 0)
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {

                      /* Make sure we start the next search at least from this entry */
                      btrfs_ioctl_search_args_set(&args, sh);

                      if (sh->objectid != 0)
                              continue;
                      if (sh->offset != qgroupid)
                              continue;

                      if (sh->type == BTRFS_QGROUP_INFO_KEY242) {
                              const struct btrfs_qgroup_info_item *qii = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)));

                              ret->referenced = le64toh(qii->rfer);
                              ret->exclusive = le64toh(qii->excl);

                              found_info = true1;

                      } else if (sh->type == BTRFS_QGROUP_LIMIT_KEY244) {
                              const struct btrfs_qgroup_limit_item *qli = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)));

                              if (le64toh(qli->flags) & BTRFS_QGROUP_LIMIT_MAX_RFER(1ULL << 0))
                                      ret->referenced_max = le64toh(qli->max_rfer);
                              else
                                      ret->referenced_max = (uint64_t) -1;

                              if (le64toh(qli->flags) & BTRFS_QGROUP_LIMIT_MAX_EXCL(1ULL << 1))
                                      ret->exclusive_max = le64toh(qli->max_excl);
                              else
                                      ret->exclusive_max = (uint64_t) -1;

                              found_limit = true1;
                      }

                      if (found_info && found_limit)
                              goto finish;
              }

              /* Increase search key by one, to read the next item, if we can. */
              if (!btrfs_ioctl_search_args_inc(&args))
                      break;
      }

617finish:
      if (!found_limit && !found_info)
              return -ENODATA61;

      if (!found_info) {
              ret->referenced = (uint64_t) -1;
              ret->exclusive = (uint64_t) -1;
      }

      if (!found_limit) {
              ret->referenced_max = (uint64_t) -1;
              ret->exclusive_max = (uint64_t) -1;
      }

      return 0;
632}

634int btrfs_qgroup_get_quota(const char *path, uint64_t qgroupid, BtrfsQuotaInfo *ret) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_qgroup_get_quota_fd(fd, qgroupid, ret);
642}

644int btrfs_subvol_find_subtree_qgroup(int fd, uint64_t subvol_id, uint64_t *ret) {
      uint64_t level, lowest = (uint64_t) -1, lowest_qgroupid = 0;
      _cleanup_free___attribute__((cleanup(freep))) uint64_t *qgroups = NULL((void*)0);
      int r, n, i;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 649, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 650
, __PRETTY_FUNCTION__); } while (0);

      /* This finds the "subtree" qgroup for a specific
       * subvolume. This only works for subvolumes that have been
       * prepared with btrfs_subvol_auto_qgroup_fd() with
       * insert_intermediary_qgroup=true (or equivalent). For others
       * it will return the leaf qgroup instead. The two cases may
       * be distuingished via the return value, which is 1 in case
       * an appropriate "subtree" qgroup was found, and 0
       * otherwise. */

      if (subvol_id == 0) {
              r = btrfs_subvol_get_id_fd(fd, &subvol_id);
              if (r < 0)
                      return r;
      }

      r = btrfs_qgroupid_split(subvol_id, &level, NULL((void*)0));
      if (r < 0)
              return r;
      if (level != 0) /* Input must be a leaf qgroup */
              return -EINVAL22;

      n = btrfs_qgroup_find_parents(fd, subvol_id, &qgroups);
      if (n < 0)
              return n;

      for (i = 0; i < n; i++) {
              uint64_t id;

              r = btrfs_qgroupid_split(qgroups[i], &level, &id);
              if (r < 0)
                      return r;

              if (id != subvol_id)
                      continue;

              if (lowest == (uint64_t) -1 || level < lowest) {
                      lowest_qgroupid = qgroups[i];
                      lowest = level;
              }
      }

      if (lowest == (uint64_t) -1) {
              /* No suitable higher-level qgroup found, let's return
               * the leaf qgroup instead, and indicate that with the
               * return value. */

              *ret = subvol_id;
              return 0;
      }

      *ret = lowest_qgroupid;
      return 1;
704}

706int btrfs_subvol_get_subtree_quota_fd(int fd, uint64_t subvol_id, BtrfsQuotaInfo *ret) {
      uint64_t qgroupid;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 710, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 711
, __PRETTY_FUNCTION__); } while (0);

      /* This determines the quota data of the qgroup with the
       * lowest level, that shares the id part with the specified
       * subvolume. This is useful for determining the quota data
       * for entire subvolume subtrees, as long as the subtrees have
       * been set up with btrfs_qgroup_subvol_auto_fd() or in a
       * compatible way */

      r = btrfs_subvol_find_subtree_qgroup(fd, subvol_id, &qgroupid);
      if (r < 0)
              return r;

      return btrfs_qgroup_get_quota_fd(fd, qgroupid, ret);
725}

727int btrfs_subvol_get_subtree_quota(const char *path, uint64_t subvol_id, BtrfsQuotaInfo *ret) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_subvol_get_subtree_quota_fd(fd, subvol_id, ret);
735}

737int btrfs_defrag_fd(int fd) {
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 740, __PRETTY_FUNCTION__); } while (0);

      r = fd_verify_regular(fd);
      if (r < 0)
              return r;

      if (ioctl(fd, BTRFS_IOC_DEFRAG(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((2)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args
)))) << ((0 +8)+8))), NULL((void*)0)) < 0)
              return -errno(*__errno_location ());

      return 0;
750}

752int btrfs_defrag(const char *p) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(p, O_RDWR02|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_defrag_fd(fd);
760}

762int btrfs_quota_enable_fd(int fd, bool_Bool b) {
      struct btrfs_ioctl_quota_ctl_args args = {
              .cmd = b ? BTRFS_QUOTA_CTL_ENABLE1 : BTRFS_QUOTA_CTL_DISABLE2,
      };
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 768, __PRETTY_FUNCTION__); } while (0);

      r = btrfs_is_filesystem(fd);
      if (r < 0)
              return r;
      if (!r)
              return -ENOTTY25;

      if (ioctl(fd, BTRFS_IOC_QUOTA_CTL(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((40)) << 0) | ((((sizeof(struct btrfs_ioctl_quota_ctl_args
)))) << ((0 +8)+8))), &args) < 0)
              return -errno(*__errno_location ());

      return 0;
780}

782int btrfs_quota_enable(const char *path, bool_Bool b) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_quota_enable_fd(fd, b);
790}

792int btrfs_qgroup_set_limit_fd(int fd, uint64_t qgroupid, uint64_t referenced_max) {

      struct btrfs_ioctl_qgroup_limit_args args = {
              .lim.max_rfer = referenced_max,
              .lim.flags = BTRFS_QGROUP_LIMIT_MAX_RFER(1ULL << 0),
      };
      unsigned c;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 801, __PRETTY_FUNCTION__); } while (0);

      if (qgroupid == 0) {
              r = btrfs_subvol_get_id_fd(fd, &qgroupid);
              if (r < 0)
                      return r;
      } else {
              r = btrfs_is_filesystem(fd);
              if (r < 0)
                      return r;
              if (!r)
                      return -ENOTTY25;
      }

      args.qgroupid = qgroupid;

      for (c = 0;; c++) {
              if (ioctl(fd, BTRFS_IOC_QGROUP_LIMIT(((2U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((43)) << 0) | ((((sizeof(struct btrfs_ioctl_qgroup_limit_args
)))) << ((0 +8)+8))), &args) < 0) {

                      if (errno(*__errno_location ()) == EBUSY16 && c < 10) {
                              (void) btrfs_quota_scan_wait(fd);
                              continue;
                      }

                      return -errno(*__errno_location ());
              }

              break;
      }

      return 0;
832}

834int btrfs_qgroup_set_limit(const char *path, uint64_t qgroupid, uint64_t referenced_max) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_qgroup_set_limit_fd(fd, qgroupid, referenced_max);
842}

844int btrfs_subvol_set_subtree_quota_limit_fd(int fd, uint64_t subvol_id, uint64_t referenced_max) {
      uint64_t qgroupid;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 848, __PRETTY_FUNCTION__); } while (0);

      r = btrfs_subvol_find_subtree_qgroup(fd, subvol_id, &qgroupid);
      if (r < 0)
              return r;

      return btrfs_qgroup_set_limit_fd(fd, qgroupid, referenced_max);
855}

857int btrfs_subvol_set_subtree_quota_limit(const char *path, uint64_t subvol_id, uint64_t referenced_max) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_CLOEXEC02000000|O_NOCTTY0400|O_NOFOLLOW0400000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_subvol_set_subtree_quota_limit_fd(fd, subvol_id, referenced_max);
865}

867int btrfs_resize_loopback_fd(int fd, uint64_t new_size, bool_Bool grow_only) {
      struct btrfs_ioctl_vol_args args = {};
      char p[SYS_BLOCK_PATH_MAX("/loop/backing_file")((sizeof("""/sys/dev/block/""") - 1) + (2+(sizeof(dev_t) <=
? 3 : sizeof(dev_t) <= 2 ? 5 : sizeof(dev_t) <= 4 ? 10
 : sizeof(dev_t) <= 8 ? 20 : sizeof(int[-2*(sizeof(dev_t) >
 8)]))) + 1 + (2+(sizeof(dev_t) <= 1 ? 3 : sizeof(dev_t) <=
? 5 : sizeof(dev_t) <= 4 ? 10 : sizeof(dev_t) <= 8 ?
: sizeof(int[-2*(sizeof(dev_t) > 8)]))) + strlen_ptr("/loop/backing_file"
))];
      _cleanup_free___attribute__((cleanup(freep))) char *backing = NULL((void*)0);
      _cleanup_close___attribute__((cleanup(closep))) int loop_fd = -1, backing_fd = -1;
      struct stat st;
      dev_t dev = 0;
      int r;

      /* In contrast to btrfs quota ioctls ftruncate() cannot make sense of "infinity" or file sizes > 2^31 */
      if (!FILE_SIZE_VALID(new_size))
              return -EINVAL22;

      /* btrfs cannot handle file systems < 16M, hence use this as minimum */
      if (new_size < 16*1024*1024)
              new_size = 16*1024*1024;

      r = btrfs_get_block_device_fd(fd, &dev);
      if (r < 0)
              return r;
      if (r == 0)
              return -ENODEV19;

      xsprintf_sys_block_path(p, "/loop/backing_file", dev)do { if ((__builtin_expect(!!(!(((size_t) snprintf(p, __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(p), typeof(&*(p))), sizeof(p)/sizeof((p)[0]), ((void)0))
), "/sys/dev/block/%u:%u%s", gnu_dev_major (dev), gnu_dev_minor
 (dev), strempty("/loop/backing_file")) < (__extension__ (
__builtin_choose_expr( !__builtin_types_compatible_p(typeof(p
), typeof(&*(p))), sizeof(p)/sizeof((p)[0]), ((void)0))))
))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("xsprintf: "
 "p" "[] must be big enough"), "../src/basic/btrfs-util.c", 890
, __PRETTY_FUNCTION__); } while (0);
      r = read_one_line_file(p, &backing);
      if (r == -ENOENT2)
              return -ENODEV19;
      if (r < 0)
              return r;
      if (isempty(backing) || !path_is_absolute(backing))
              return -ENODEV19;

      backing_fd = open(backing, O_RDWR02|O_CLOEXEC02000000|O_NOCTTY0400);
      if (backing_fd < 0)
              return -errno(*__errno_location ());

      if (fstat(backing_fd, &st) < 0)
              return -errno(*__errno_location ());
      if (!S_ISREG(st.st_mode)((((st.st_mode)) & 0170000) == (0100000)))
              return -ENODEV19;

      if (new_size == (uint64_t) st.st_size)
              return 0;

      if (grow_only && new_size < (uint64_t) st.st_size)
              return -EINVAL22;

      xsprintf_sys_block_path(p, NULL, dev)do { if ((__builtin_expect(!!(!(((size_t) snprintf(p, __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(p), typeof(&*(p))), sizeof(p)/sizeof((p)[0]), ((void)0))
), "/sys/dev/block/%u:%u%s", gnu_dev_major (dev), gnu_dev_minor
 (dev), strempty(((void*)0))) < (__extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(p), typeof(&*(p)))
, sizeof(p)/sizeof((p)[0]), ((void)0))))))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("xsprintf: " "p" "[] must be big enough"
), "../src/basic/btrfs-util.c", 914, __PRETTY_FUNCTION__); } while
 (0);
      loop_fd = open(p, O_RDWR02|O_CLOEXEC02000000|O_NOCTTY0400);
      if (loop_fd < 0)
              return -errno(*__errno_location ());

      if (snprintf(args.name, sizeof(args.name), "%" PRIu64"l" "u", new_size) >= (int) sizeof(args.name))
              return -EINVAL22;

      if (new_size < (uint64_t) st.st_size) {
              /* Decrease size: first decrease btrfs size, then shorten loopback */
              if (ioctl(fd, BTRFS_IOC_RESIZE(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((3)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args
)))) << ((0 +8)+8))), &args) < 0)
                      return -errno(*__errno_location ());
      }

      if (ftruncate(backing_fd, new_size) < 0)
              return -errno(*__errno_location ());

      if (ioctl(loop_fd, LOOP_SET_CAPACITY0x4C07, 0) < 0)
              return -errno(*__errno_location ());

      if (new_size > (uint64_t) st.st_size) {
              /* Increase size: first enlarge loopback, then increase btrfs size */
              if (ioctl(fd, BTRFS_IOC_RESIZE(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((3)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args
)))) << ((0 +8)+8))), &args) < 0)
                      return -errno(*__errno_location ());
      }

      /* Make sure the free disk space is correctly updated for both file systems */
      (void) fsync(fd);
      (void) fsync(backing_fd);

      return 1;
945}

947int btrfs_resize_loopback(const char *p, uint64_t new_size, bool_Bool grow_only) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(p, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_resize_loopback_fd(fd, new_size, grow_only);
955}

957int btrfs_qgroupid_make(uint64_t level, uint64_t id, uint64_t *ret) {
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 958
, __PRETTY_FUNCTION__); } while (0);

      if (level >= (UINT64_C(1)1UL << (64 - BTRFS_QGROUP_LEVEL_SHIFT48)))
              return -EINVAL22;

      if (id >= (UINT64_C(1)1UL << BTRFS_QGROUP_LEVEL_SHIFT48))
              return -EINVAL22;

      *ret = (level << BTRFS_QGROUP_LEVEL_SHIFT48) | id;
      return 0;
968}

970int btrfs_qgroupid_split(uint64_t qgroupid, uint64_t *level, uint64_t *id) {
      assert(level || id)do { if ((__builtin_expect(!!(!(level || id)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("level || id"), "../src/basic/btrfs-util.c"
, 971, __PRETTY_FUNCTION__); } while (0);

      if (level)
              *level = qgroupid >> BTRFS_QGROUP_LEVEL_SHIFT48;

      if (id)
              *id = qgroupid & ((UINT64_C(1)1UL << BTRFS_QGROUP_LEVEL_SHIFT48) - 1);

      return 0;
980}

982static int qgroup_create_or_destroy(int fd, bool_Bool b, uint64_t qgroupid) {

      struct btrfs_ioctl_qgroup_create_args args = {
              .create = b,
              .qgroupid = qgroupid,
      };
      unsigned c;
      int r;

      r = btrfs_is_filesystem(fd);
      if (r < 0)
              return r;
      if (r == 0)
              return -ENOTTY25;

      for (c = 0;; c++) {
              if (ioctl(fd, BTRFS_IOC_QGROUP_CREATE(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((42)) << 0) | ((((sizeof(struct btrfs_ioctl_qgroup_create_args
)))) << ((0 +8)+8))), &args) < 0) {

                      /* If quota is not enabled, we get EINVAL. Turn this into a recognizable error */
                      if (errno(*__errno_location ()) == EINVAL22)
                              return -ENOPROTOOPT92;

                      if (errno(*__errno_location ()) == EBUSY16 && c < 10) {
                              (void) btrfs_quota_scan_wait(fd);
                              continue;
                      }

                      return -errno(*__errno_location ());
              }

              break;
      }

      return 0;
1016}

1018int btrfs_qgroup_create(int fd, uint64_t qgroupid) {
      return qgroup_create_or_destroy(fd, true1, qgroupid);
1020}

1022int btrfs_qgroup_destroy(int fd, uint64_t qgroupid) {
      return qgroup_create_or_destroy(fd, false0, qgroupid);
1024}

1026int btrfs_qgroup_destroy_recursive(int fd, uint64_t qgroupid) {
      _cleanup_free___attribute__((cleanup(freep))) uint64_t *qgroups = NULL((void*)0);
      uint64_t subvol_id;
      int i, n, r;

      /* Destroys the specified qgroup, but unassigns it from all
       * its parents first. Also, it recursively destroys all
       * qgroups it is assgined to that have the same id part of the
       * qgroupid as the specified group. */

      r = btrfs_qgroupid_split(qgroupid, NULL((void*)0), &subvol_id);
      if (r < 0)
              return r;

      n = btrfs_qgroup_find_parents(fd, qgroupid, &qgroups);
      if (n < 0)
              return n;

      for (i = 0; i < n; i++) {
              uint64_t id;

              r = btrfs_qgroupid_split(qgroups[i], NULL((void*)0), &id);
              if (r < 0)
                      return r;

              r = btrfs_qgroup_unassign(fd, qgroupid, qgroups[i]);
              if (r < 0)
                      return r;

              if (id != subvol_id)
                      continue;

              /* The parent qgroupid shares the same id part with
               * us? If so, destroy it too. */

              (void) btrfs_qgroup_destroy_recursive(fd, qgroups[i]);
      }

      return btrfs_qgroup_destroy(fd, qgroupid);
1065}

1067int btrfs_quota_scan_start(int fd) {
      struct btrfs_ioctl_quota_rescan_args args = {};

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1070, __PRETTY_FUNCTION__); } while (0);

      if (ioctl(fd, BTRFS_IOC_QUOTA_RESCAN(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((44)) << 0) | ((((sizeof(struct btrfs_ioctl_quota_rescan_args
)))) << ((0 +8)+8))), &args) < 0)
              return -errno(*__errno_location ());

      return 0;
1076}

1078int btrfs_quota_scan_wait(int fd) {
      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1079, __PRETTY_FUNCTION__); } while (0);

      if (ioctl(fd, BTRFS_IOC_QUOTA_RESCAN_WAIT(((0U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((46)) << 0) | ((0) << ((0 +8)+8)))) < 0)
              return -errno(*__errno_location ());

      return 0;
1085}

1087int btrfs_quota_scan_ongoing(int fd) {
      struct btrfs_ioctl_quota_rescan_args args = {};

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1090, __PRETTY_FUNCTION__); } while (0);

      if (ioctl(fd, BTRFS_IOC_QUOTA_RESCAN_STATUS(((2U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((45)) << 0) | ((((sizeof(struct btrfs_ioctl_quota_rescan_args
)))) << ((0 +8)+8))), &args) < 0)
              return -errno(*__errno_location ());

      return !!args.flags;
1096}

1098static int qgroup_assign_or_unassign(int fd, bool_Bool b, uint64_t child, uint64_t parent) {
      struct btrfs_ioctl_qgroup_assign_args args = {
              .assign = b,
              .src = child,
              .dst = parent,
      };
      unsigned c;
      int r;

      r = btrfs_is_filesystem(fd);
      if (r < 0)
              return r;
      if (r == 0)
              return -ENOTTY25;

      for (c = 0;; c++) {
              r = ioctl(fd, BTRFS_IOC_QGROUP_ASSIGN(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((41)) << 0) | ((((sizeof(struct btrfs_ioctl_qgroup_assign_args
)))) << ((0 +8)+8))), &args);
              if (r < 0) {
                      if (errno(*__errno_location ()) == EBUSY16 && c < 10) {
                              (void) btrfs_quota_scan_wait(fd);
                              continue;
                      }

                      return -errno(*__errno_location ());
              }

              if (r == 0)
                      return 0;

              /* If the return value is > 0, we need to request a rescan */

              (void) btrfs_quota_scan_start(fd);
              return 1;
      }
1132}

1134int btrfs_qgroup_assign(int fd, uint64_t child, uint64_t parent) {
      return qgroup_assign_or_unassign(fd, true1, child, parent);
1136}

1138int btrfs_qgroup_unassign(int fd, uint64_t child, uint64_t parent) {
      return qgroup_assign_or_unassign(fd, false0, child, parent);
1140}

1142static int subvol_remove_children(int fd, const char *subvolume, uint64_t subvol_id, BtrfsRemoveFlags flags) {
      struct btrfs_ioctl_search_args args = {
              .key.tree_id = BTRFS_ROOT_TREE_OBJECTID1,

              .key.min_objectid = BTRFS_FIRST_FREE_OBJECTID256,
              .key.max_objectid = BTRFS_LAST_FREE_OBJECTID-256ULL,

              .key.min_type = BTRFS_ROOT_BACKREF_KEY144,
              .key.max_type = BTRFS_ROOT_BACKREF_KEY144,

              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };

      struct btrfs_ioctl_vol_args vol_args = {};
      _cleanup_close___attribute__((cleanup(closep))) int subvol_fd = -1;
      struct stat st;
      bool_Bool made_writable = false0;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1162, __PRETTY_FUNCTION__); } while (0);
      assert(subvolume)do { if ((__builtin_expect(!!(!(subvolume)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("subvolume"), "../src/basic/btrfs-util.c"
, 1163, __PRETTY_FUNCTION__); } while (0);

      if (fstat(fd, &st) < 0)
              return -errno(*__errno_location ());

      if (!S_ISDIR(st.st_mode)((((st.st_mode)) & 0170000) == (0040000)))
              return -EINVAL22;

      subvol_fd = openat(fd, subvolume, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000|O_NOFOLLOW0400000);
      if (subvol_fd < 0)
              return -errno(*__errno_location ());

      if (subvol_id == 0) {
              r = btrfs_subvol_get_id_fd(subvol_fd, &subvol_id);
              if (r < 0)
                      return r;
      }

      /* First, try to remove the subvolume. If it happens to be
       * already empty, this will just work. */
      strncpy(vol_args.name, subvolume, sizeof(vol_args.name)-1);
      if (ioctl(fd, BTRFS_IOC_SNAP_DESTROY(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((15)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args
)))) << ((0 +8)+8))), &vol_args) >= 0) {
              (void) btrfs_qgroup_destroy_recursive(fd, subvol_id); /* for the leaf subvolumes, the qgroup id is identical to the subvol id */
              return 0;
      }
      if (!(flags & BTRFS_REMOVE_RECURSIVE) || errno(*__errno_location ()) != ENOTEMPTY39)
              return -errno(*__errno_location ());

      /* OK, the subvolume is not empty, let's look for child
       * subvolumes, and remove them, first */

      args.key.min_offset = args.key.max_offset = subvol_id;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0)
                      return -errno(*__errno_location ());

              if (args.key.nr_items <= 0)
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {
                      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
                      const struct btrfs_root_ref *ref;
                      struct btrfs_ioctl_ino_lookup_args ino_args;

                      btrfs_ioctl_search_args_set(&args, sh);

                      if (sh->type != BTRFS_ROOT_BACKREF_KEY144)
                              continue;
                      if (sh->offset != subvol_id)
                              continue;

                      ref = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)));

                      p = strndup((char*) ref + sizeof(struct btrfs_root_ref), le64toh(ref->name_len));
                      if (!p)
                              return -ENOMEM12;

                      zero(ino_args)(({ size_t _l_ = (sizeof(ino_args)); void *_x_ = (&(ino_args
)); _l_ == 0 ? _x_ : memset(_x_, 0, _l_); }));
                      ino_args.treeid = subvol_id;
                      ino_args.objectid = htole64(ref->dirid);

                      if (ioctl(fd, BTRFS_IOC_INO_LOOKUP(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((18)) << 0) | ((((sizeof(struct btrfs_ioctl_ino_lookup_args
)))) << ((0 +8)+8))), &ino_args) < 0)
                              return -errno(*__errno_location ());

                      if (!made_writable) {
                              r = btrfs_subvol_set_read_only_fd(subvol_fd, false0);
                              if (r < 0)
                                      return r;

                              made_writable = true1;
                      }

                      if (isempty(ino_args.name))
                              /* Subvolume is in the top-level
                               * directory of the subvolume. */
                              r = subvol_remove_children(subvol_fd, p, sh->objectid, flags);
                      else {
                              _cleanup_close___attribute__((cleanup(closep))) int child_fd = -1;

                              /* Subvolume is somewhere further down,
                               * hence we need to open the
                               * containing directory first */

                              child_fd = openat(subvol_fd, ino_args.name, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000|O_NOFOLLOW0400000);
                              if (child_fd < 0)
                                      return -errno(*__errno_location ());

                              r = subvol_remove_children(child_fd, p, sh->objectid, flags);
                      }
                      if (r < 0)
                              return r;
              }

              /* Increase search key by one, to read the next item, if we can. */
              if (!btrfs_ioctl_search_args_inc(&args))
                      break;
      }

      /* OK, the child subvolumes should all be gone now, let's try
       * again to remove the subvolume */
      if (ioctl(fd, BTRFS_IOC_SNAP_DESTROY(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((15)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args
)))) << ((0 +8)+8))), &vol_args) < 0)
              return -errno(*__errno_location ());

      (void) btrfs_qgroup_destroy_recursive(fd, subvol_id);
      return 0;
1273}

1275int btrfs_subvol_remove(const char *path, BtrfsRemoveFlags flags) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;
      const char *subvolume;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/btrfs-util.c", 1280
, __PRETTY_FUNCTION__); } while (0);

      r = extract_subvolume_name(path, &subvolume);
      if (r < 0)
              return r;

      fd = open_parent(path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (fd < 0)
              return fd;

      return subvol_remove_children(fd, subvolume, 0, flags);
1291}

1293int btrfs_subvol_remove_fd(int fd, const char *subvolume, BtrfsRemoveFlags flags) {
      return subvol_remove_children(fd, subvolume, 0, flags);
1295}

1297int btrfs_qgroup_copy_limits(int fd, uint64_t old_qgroupid, uint64_t new_qgroupid) {

      struct btrfs_ioctl_search_args args = {
              /* Tree of quota items */
              .key.tree_id = BTRFS_QUOTA_TREE_OBJECTID8ULL,

              /* The object ID is always 0 */
              .key.min_objectid = 0,
              .key.max_objectid = 0,

              /* Look precisely for the quota items */
              .key.min_type = BTRFS_QGROUP_LIMIT_KEY244,
              .key.max_type = BTRFS_QGROUP_LIMIT_KEY244,

              /* For our qgroup */
              .key.min_offset = old_qgroupid,
              .key.max_offset = old_qgroupid,

              /* No restrictions on the other components */
              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };

      int r;

      r = btrfs_is_filesystem(fd);
      if (r < 0)
              return r;
      if (!r)
              return -ENOTTY25;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0) {
                      if (errno(*__errno_location ()) == ENOENT2) /* quota tree missing: quota is not enabled, hence nothing to copy */
                              break;

                      return -errno(*__errno_location ());
              }

              if (args.key.nr_items <= 0)
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {
                      const struct btrfs_qgroup_limit_item *qli = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)));
                      struct btrfs_ioctl_qgroup_limit_args qargs;
                      unsigned c;

                      /* Make sure we start the next search at least from this entry */
                      btrfs_ioctl_search_args_set(&args, sh);

                      if (sh->objectid != 0)
                              continue;
                      if (sh->type != BTRFS_QGROUP_LIMIT_KEY244)
                              continue;
                      if (sh->offset != old_qgroupid)
                              continue;

                      /* We found the entry, now copy things over. */

                      qargs = (struct btrfs_ioctl_qgroup_limit_args) {
                              .qgroupid = new_qgroupid,

                              .lim.max_rfer = le64toh(qli->max_rfer),
                              .lim.max_excl = le64toh(qli->max_excl),
                              .lim.rsv_rfer = le64toh(qli->rsv_rfer),
                              .lim.rsv_excl = le64toh(qli->rsv_excl),

                              .lim.flags = le64toh(qli->flags) & (BTRFS_QGROUP_LIMIT_MAX_RFER(1ULL << 0)|
                                                                  BTRFS_QGROUP_LIMIT_MAX_EXCL(1ULL << 1)|
                                                                  BTRFS_QGROUP_LIMIT_RSV_RFER(1ULL << 2)|
                                                                  BTRFS_QGROUP_LIMIT_RSV_EXCL(1ULL << 3)),
                      };

                      for (c = 0;; c++) {
                              if (ioctl(fd, BTRFS_IOC_QGROUP_LIMIT(((2U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((43)) << 0) | ((((sizeof(struct btrfs_ioctl_qgroup_limit_args
)))) << ((0 +8)+8))), &qargs) < 0) {
                                      if (errno(*__errno_location ()) == EBUSY16 && c < 10) {
                                              (void) btrfs_quota_scan_wait(fd);
                                              continue;
                                      }
                                      return -errno(*__errno_location ());
                              }

                              break;
                      }

                      return 1;
              }

              /* Increase search key by one, to read the next item, if we can. */
              if (!btrfs_ioctl_search_args_inc(&args))
                      break;
      }

      return 0;
1395}

1397static int copy_quota_hierarchy(int fd, uint64_t old_subvol_id, uint64_t new_subvol_id) {
      _cleanup_free___attribute__((cleanup(freep))) uint64_t *old_qgroups = NULL((void*)0), *old_parent_qgroups = NULL((void*)0);
      bool_Bool copy_from_parent = false0, insert_intermediary_qgroup = false0;
      int n_old_qgroups, n_old_parent_qgroups, r, i;
      uint64_t old_parent_id;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1403, __PRETTY_FUNCTION__); } while (0);

      /* Copies a reduced form of quota information from the old to
       * the new subvolume. */

      n_old_qgroups = btrfs_qgroup_find_parents(fd, old_subvol_id, &old_qgroups);
      if (n_old_qgroups <= 0) /* Nothing to copy */
              return n_old_qgroups;

      r = btrfs_subvol_get_parent(fd, old_subvol_id, &old_parent_id);
      if (r == -ENXIO6)
              /* We have no parent, hence nothing to copy. */
              n_old_parent_qgroups = 0;
      else if (r < 0)
              return r;
      else {
              n_old_parent_qgroups = btrfs_qgroup_find_parents(fd, old_parent_id, &old_parent_qgroups);
              if (n_old_parent_qgroups < 0)
                      return n_old_parent_qgroups;
      }

      for (i = 0; i < n_old_qgroups; i++) {
              uint64_t id;
              int j;

              r = btrfs_qgroupid_split(old_qgroups[i], NULL((void*)0), &id);
              if (r < 0)
                      return r;

              if (id == old_subvol_id) {
                      /* The old subvolume was member of a qgroup
                       * that had the same id, but a different level
                       * as it self. Let's set up something similar
                       * in the destination. */
                      insert_intermediary_qgroup = true1;
                      break;
              }

              for (j = 0; j < n_old_parent_qgroups; j++)
                      if (old_parent_qgroups[j] == old_qgroups[i]) {
                              /* The old subvolume shared a common
                               * parent qgroup with its parent
                               * subvolume. Let's set up something
                               * similar in the destination. */
                              copy_from_parent = true1;
                      }
      }

      if (!insert_intermediary_qgroup && !copy_from_parent)
              return 0;

      return btrfs_subvol_auto_qgroup_fd(fd, new_subvol_id, insert_intermediary_qgroup);
1455}

1457static int copy_subtree_quota_limits(int fd, uint64_t old_subvol, uint64_t new_subvol) {
      uint64_t old_subtree_qgroup, new_subtree_qgroup;
      bool_Bool changed;
      int r;

      /* First copy the leaf limits */
      r = btrfs_qgroup_copy_limits(fd, old_subvol, new_subvol);
      if (r < 0)
              return r;
      changed = r > 0;

      /* Then, try to copy the subtree limits, if there are any. */
      r = btrfs_subvol_find_subtree_qgroup(fd, old_subvol, &old_subtree_qgroup);
      if (r < 0)
              return r;
      if (r == 0)
              return changed;

      r = btrfs_subvol_find_subtree_qgroup(fd, new_subvol, &new_subtree_qgroup);
      if (r < 0)
              return r;
      if (r == 0)
              return changed;

      r = btrfs_qgroup_copy_limits(fd, old_subtree_qgroup, new_subtree_qgroup);
      if (r != 0)
              return r;

      return changed;
1486}

1488static int subvol_snapshot_children(int old_fd, int new_fd, const char *subvolume, uint64_t old_subvol_id, BtrfsSnapshotFlags flags) {

      struct btrfs_ioctl_search_args args = {
              .key.tree_id = BTRFS_ROOT_TREE_OBJECTID1,

              .key.min_objectid = BTRFS_FIRST_FREE_OBJECTID256,
              .key.max_objectid = BTRFS_LAST_FREE_OBJECTID-256ULL,

              .key.min_type = BTRFS_ROOT_BACKREF_KEY144,
              .key.max_type = BTRFS_ROOT_BACKREF_KEY144,

              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };

      struct btrfs_ioctl_vol_args_v2 vol_args = {
              .flags = flags & BTRFS_SNAPSHOT_READ_ONLY ? BTRFS_SUBVOL_RDONLY(1ULL << 1) : 0,
21
←
Assuming the condition is false→
22
←
'?' condition is false→
              .fd = old_fd,
      };
      _cleanup_close___attribute__((cleanup(closep))) int subvolume_fd = -1;
      uint64_t new_subvol_id;
23
←
'new_subvol_id' declared without an initial value→
      int r;

      assert(old_fd >= 0)do { if ((__builtin_expect(!!(!(old_fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("old_fd >= 0"), "../src/basic/btrfs-util.c"
, 1511, __PRETTY_FUNCTION__); } while (0);
24
←
Taking false branch→
25
←
Loop condition is false.  Exiting loop→
      assert(new_fd >= 0)do { if ((__builtin_expect(!!(!(new_fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("new_fd >= 0"), "../src/basic/btrfs-util.c"
, 1512, __PRETTY_FUNCTION__); } while (0);
26
←
Taking false branch→
27
←
Loop condition is false.  Exiting loop→
      assert(subvolume)do { if ((__builtin_expect(!!(!(subvolume)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("subvolume"), "../src/basic/btrfs-util.c"
, 1513, __PRETTY_FUNCTION__); } while (0);
28
←
Taking false branch→
29
←
Loop condition is false.  Exiting loop→

      strncpy(vol_args.name, subvolume, sizeof(vol_args.name)-1);

      if (ioctl(new_fd, BTRFS_IOC_SNAP_CREATE_V2(((1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +8))
 | (((23)) << 0) | ((((sizeof(struct btrfs_ioctl_vol_args_v2
)))) << ((0 +8)+8))), &vol_args) < 0)
30
←
Assuming the condition is false→
31
←
Taking false branch→
              return -errno(*__errno_location ());

      if (!(flags & BTRFS_SNAPSHOT_RECURSIVE) &&
32
←
Assuming the condition is false→
          !(flags & BTRFS_SNAPSHOT_QUOTA))
              return 0;

      if (old_subvol_id32.1
'old_subvol_id' is equal to 0
 == 0) {
33
←
Taking true branch→
              r = btrfs_subvol_get_id_fd(old_fd, &old_subvol_id);
              if (r < 0)
34
←
Assuming 'r' is >= 0→
35
←
Taking false branch→
                      return r;
      }

      r = btrfs_subvol_get_id(new_fd, vol_args.name, &new_subvol_id);
36
←
Calling 'btrfs_subvol_get_id'→
44
←
Returning from 'btrfs_subvol_get_id'→
      if (r < 0)
45
←
Assuming 'r' is >= 0→
46
←
Taking false branch→
              return r;

      if (flags & BTRFS_SNAPSHOT_QUOTA)
47
←
Assuming the condition is false→
48
←
Taking false branch→
              (void) copy_quota_hierarchy(new_fd, old_subvol_id, new_subvol_id);

      if (!(flags & BTRFS_SNAPSHOT_RECURSIVE)) {
49
←
Taking false branch→

              if (flags & BTRFS_SNAPSHOT_QUOTA)
                      (void) copy_subtree_quota_limits(new_fd, old_subvol_id, new_subvol_id);

              return 0;
      }

      args.key.min_offset = args.key.max_offset = old_subvol_id;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
50
←
Assuming the condition is true→
51
←
Loop condition is true.  Entering loop body→
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(old_fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0)
52
←
Assuming the condition is false→
53
←
Taking false branch→
                      return -errno(*__errno_location ());

              if (args.key.nr_items <= 0)
54
←
Assuming field 'nr_items' is > 0→
55
←
Taking false branch→
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {
56
←
Loop condition is true.  Entering loop body→
                      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *c = NULL((void*)0), *np = NULL((void*)0);
                      struct btrfs_ioctl_ino_lookup_args ino_args;
                      const struct btrfs_root_ref *ref;
                      _cleanup_close___attribute__((cleanup(closep))) int old_child_fd = -1, new_child_fd = -1;

                      btrfs_ioctl_search_args_set(&args, sh);

                      if (sh->type != BTRFS_ROOT_BACKREF_KEY144)
57
←
Assuming field 'type' is equal to BTRFS_ROOT_BACKREF_KEY→
58
←
Taking false branch→
                              continue;

                      /* Avoid finding the source subvolume a second
                       * time */
                      if (sh->offset != old_subvol_id)
59
←
Assuming 'old_subvol_id' is equal to field 'offset'→
60
←
Taking false branch→
                              continue;

                      /* Avoid running into loops if the new
                       * subvolume is below the old one. */
                      if (sh->objectid == new_subvol_id)
61
←
The right operand of '==' is a garbage value
                              continue;

                      ref = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh)((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header
)));
                      p = strndup((char*) ref + sizeof(struct btrfs_root_ref), le64toh(ref->name_len));
                      if (!p)
                              return -ENOMEM12;

                      zero(ino_args)(({ size_t _l_ = (sizeof(ino_args)); void *_x_ = (&(ino_args
)); _l_ == 0 ? _x_ : memset(_x_, 0, _l_); }));
                      ino_args.treeid = old_subvol_id;
                      ino_args.objectid = htole64(ref->dirid);

                      if (ioctl(old_fd, BTRFS_IOC_INO_LOOKUP(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((18)) << 0) | ((((sizeof(struct btrfs_ioctl_ino_lookup_args
)))) << ((0 +8)+8))), &ino_args) < 0)
                              return -errno(*__errno_location ());

                      /* The kernel returns an empty name if the
                       * subvolume is in the top-level directory,
                       * and otherwise appends a slash, so that we
                       * can just concatenate easily here, without
                       * adding a slash. */
                      c = strappend(ino_args.name, p);
                      if (!c)
                              return -ENOMEM12;

                      old_child_fd = openat(old_fd, c, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000|O_NOFOLLOW0400000);
                      if (old_child_fd < 0)
                              return -errno(*__errno_location ());

                      np = strjoin(subvolume, "/", ino_args.name)strjoin_real((subvolume), "/", ino_args.name, ((void*)0));
                      if (!np)
                              return -ENOMEM12;

                      new_child_fd = openat(new_fd, np, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000|O_NOFOLLOW0400000);
                      if (new_child_fd < 0)
                              return -errno(*__errno_location ());

                      if (flags & BTRFS_SNAPSHOT_READ_ONLY) {
                              /* If the snapshot is read-only we
                               * need to mark it writable
                               * temporarily, to put the subsnapshot
                               * into place. */

                              if (subvolume_fd < 0) {
                                      subvolume_fd = openat(new_fd, subvolume, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000|O_NOFOLLOW0400000);
                                      if (subvolume_fd < 0)
                                              return -errno(*__errno_location ());
                              }

                              r = btrfs_subvol_set_read_only_fd(subvolume_fd, false0);
                              if (r < 0)
                                      return r;
                      }

                      /* When btrfs clones the subvolumes, child
                       * subvolumes appear as empty directories. Remove
                       * them, so that we can create a new snapshot
                       * in their place */
                      if (unlinkat(new_child_fd, p, AT_REMOVEDIR0x200) < 0) {
                              int k = -errno(*__errno_location ());

                              if (flags & BTRFS_SNAPSHOT_READ_ONLY)
                                      (void) btrfs_subvol_set_read_only_fd(subvolume_fd, true1);

                              return k;
                      }

                      r = subvol_snapshot_children(old_child_fd, new_child_fd, p, sh->objectid, flags & ~BTRFS_SNAPSHOT_FALLBACK_COPY);

                      /* Restore the readonly flag */
                      if (flags & BTRFS_SNAPSHOT_READ_ONLY) {
                              int k;

                              k = btrfs_subvol_set_read_only_fd(subvolume_fd, true1);
                              if (r >= 0 && k < 0)
                                      return k;
                      }

                      if (r < 0)
                              return r;
              }

              /* Increase search key by one, to read the next item, if we can. */
              if (!btrfs_ioctl_search_args_inc(&args))
                      break;
      }

      if (flags & BTRFS_SNAPSHOT_QUOTA)
              (void) copy_subtree_quota_limits(new_fd, old_subvol_id, new_subvol_id);

      return 0;
1666}

1668int btrfs_subvol_snapshot_fd(int old_fd, const char *new_path, BtrfsSnapshotFlags flags) {
      _cleanup_close___attribute__((cleanup(closep))) int new_fd = -1;
      const char *subvolume;
      int r;

      assert(old_fd >= 0)do { if ((__builtin_expect(!!(!(old_fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("old_fd >= 0"), "../src/basic/btrfs-util.c"
, 1673, __PRETTY_FUNCTION__); } while (0);
10
←
Taking false branch→
11
←
Loop condition is false.  Exiting loop→
      assert(new_path)do { if ((__builtin_expect(!!(!(new_path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("new_path"), "../src/basic/btrfs-util.c"
, 1674, __PRETTY_FUNCTION__); } while (0);
12
←
Taking false branch→
13
←
Loop condition is false.  Exiting loop→

      r = btrfs_is_subvol_fd(old_fd);
      if (r < 0)
14
←
Assuming 'r' is >= 0→
15
←
Taking false branch→
              return r;
      if (r == 0) {
16
←
Assuming 'r' is not equal to 0→
17
←
Taking false branch→
              bool_Bool plain_directory = false0;

              /* If the source isn't a proper subvolume, fail unless fallback is requested */
              if (!(flags & BTRFS_SNAPSHOT_FALLBACK_COPY))
                      return -EISDIR21;

              r = btrfs_subvol_make(new_path);
              if (r == -ENOTTY25 && (flags & BTRFS_SNAPSHOT_FALLBACK_DIRECTORY)) {
                      /* If the destination doesn't support subvolumes, then use a plain directory, if that's requested. */
                      if (mkdir(new_path, 0755) < 0)
                              return -errno(*__errno_location ());

                      plain_directory = true1;
              } else if (r < 0)
                      return r;

              r = copy_directory_fd(old_fd, new_path, COPY_MERGE|COPY_REFLINK);
              if (r < 0)
                      goto fallback_fail;

              if (flags & BTRFS_SNAPSHOT_READ_ONLY) {

                      if (plain_directory) {
                              /* Plain directories have no recursive read-only flag, but something pretty close to
                               * it: the IMMUTABLE bit. Let's use this here, if this is requested. */

                              if (flags & BTRFS_SNAPSHOT_FALLBACK_IMMUTABLE)
                                      (void) chattr_path(new_path, FS_IMMUTABLE_FL0x00000010, FS_IMMUTABLE_FL0x00000010);
                      } else {
                              r = btrfs_subvol_set_read_only(new_path, true1);
                              if (r < 0)
                                      goto fallback_fail;
                      }
              }

              return 0;

      fallback_fail:
              (void) rm_rf(new_path, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_SUBVOLUME);
              return r;
      }

      r = extract_subvolume_name(new_path, &subvolume);
      if (r17.1
'r' is >= 0
 < 0)
18
←
Taking false branch→
              return r;

      new_fd = open_parent(new_path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (new_fd18.1
'new_fd' is >= 0
 < 0)
19
←
Taking false branch→
              return new_fd;

      return subvol_snapshot_children(old_fd, new_fd, subvolume, 0, flags);
20
←
Calling 'subvol_snapshot_children'→
1731}

1733int btrfs_subvol_snapshot(const char *old_path, const char *new_path, BtrfsSnapshotFlags flags) {
      _cleanup_close___attribute__((cleanup(closep))) int old_fd = -1;

      assert(old_path)do { if ((__builtin_expect(!!(!(old_path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("old_path"), "../src/basic/btrfs-util.c"
, 1736, __PRETTY_FUNCTION__); } while (0);
1
Assuming 'old_path' is non-null→
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→
      assert(new_path)do { if ((__builtin_expect(!!(!(new_path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("new_path"), "../src/basic/btrfs-util.c"
, 1737, __PRETTY_FUNCTION__); } while (0);
4
←
Assuming 'new_path' is non-null→
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→

      old_fd = open(old_path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (old_fd < 0)
7
←
Assuming 'old_fd' is >= 0→
8
←
Taking false branch→
              return -errno(*__errno_location ());

      return btrfs_subvol_snapshot_fd(old_fd, new_path, flags);
9
←
Calling 'btrfs_subvol_snapshot_fd'→
1744}

1746int btrfs_qgroup_find_parents(int fd, uint64_t qgroupid, uint64_t **ret) {

      struct btrfs_ioctl_search_args args = {
              /* Tree of quota items */
              .key.tree_id = BTRFS_QUOTA_TREE_OBJECTID8ULL,

              /* Look precisely for the quota relation items */
              .key.min_type = BTRFS_QGROUP_RELATION_KEY246,
              .key.max_type = BTRFS_QGROUP_RELATION_KEY246,

              /* No restrictions on the other components */
              .key.min_offset = 0,
              .key.max_offset = (uint64_t) -1,

              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };

      _cleanup_free___attribute__((cleanup(freep))) uint64_t *items = NULL((void*)0);
      size_t n_items = 0, n_allocated = 0;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1768, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 1769
, __PRETTY_FUNCTION__); } while (0);

      if (qgroupid == 0) {
              r = btrfs_subvol_get_id_fd(fd, &qgroupid);
              if (r < 0)
                      return r;
      } else {
              r = btrfs_is_filesystem(fd);
              if (r < 0)
                      return r;
              if (!r)
                      return -ENOTTY25;
      }

      args.key.min_objectid = args.key.max_objectid = qgroupid;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0) {
                      if (errno(*__errno_location ()) == ENOENT2) /* quota tree missing: quota is disabled */
                              break;

                      return -errno(*__errno_location ());
              }

              if (args.key.nr_items <= 0)
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {

                      /* Make sure we start the next search at least from this entry */
                      btrfs_ioctl_search_args_set(&args, sh);

                      if (sh->type != BTRFS_QGROUP_RELATION_KEY246)
                              continue;
                      if (sh->offset < sh->objectid)
                              continue;
                      if (sh->objectid != qgroupid)
                              continue;

                      if (!GREEDY_REALLOC(items, n_allocated, n_items+1)greedy_realloc((void**) &(items), &(n_allocated), (n_items
+1), sizeof((items)[0])))
                              return -ENOMEM12;

                      items[n_items++] = sh->offset;
              }

              /* Increase search key by one, to read the next item, if we can. */
              if (!btrfs_ioctl_search_args_inc(&args))
                      break;
      }

      if (n_items <= 0) {
              *ret = NULL((void*)0);
              return 0;
      }

      *ret = TAKE_PTR(items)({ typeof(items) _ptr_ = (items); (items) = ((void*)0); _ptr_
; });

      return (int) n_items;
1831}

1833int btrfs_subvol_auto_qgroup_fd(int fd, uint64_t subvol_id, bool_Bool insert_intermediary_qgroup) {
      _cleanup_free___attribute__((cleanup(freep))) uint64_t *qgroups = NULL((void*)0);
      uint64_t parent_subvol;
      bool_Bool changed = false0;
      int n = 0, r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 1839, __PRETTY_FUNCTION__); } while (0);

      /*
       * Sets up the specified subvolume's qgroup automatically in
       * one of two ways:
       *
       * If insert_intermediary_qgroup is false, the subvolume's
       * leaf qgroup will be assigned to the same parent qgroups as
       * the subvolume's parent subvolume.
       *
       * If insert_intermediary_qgroup is true a new intermediary
       * higher-level qgroup is created, with a higher level number,
       * but reusing the id of the subvolume. The level number is
       * picked as one smaller than the lowest level qgroup the
       * parent subvolume is a member of. If the parent subvolume's
       * leaf qgroup is assigned to no higher-level qgroup a new
       * qgroup of level 255 is created instead. Either way, the new
       * qgroup is then assigned to the parent's higher-level
       * qgroup, and the subvolume itself is assigned to it.
       *
       * If the subvolume is already assigned to a higher level
       * qgroup, no operation is executed.
       *
       * Effectively this means: regardless if
       * insert_intermediary_qgroup is true or not, after this
       * function is invoked the subvolume will be accounted within
       * the same qgroups as the parent. However, if it is true, it
       * will also get its own higher-level qgroup, which may in
       * turn be used by subvolumes created beneath this subvolume
       * later on.
       *
       * This hence defines a simple default qgroup setup for
       * subvolumes, as long as this function is invoked on each
       * created subvolume: each subvolume is always accounting
       * together with its immediate parents. Optionally, if
       * insert_intermediary_qgroup is true, it will also get a
       * qgroup that then includes all its own child subvolumes.
       */

      if (subvol_id == 0) {
              r = btrfs_is_subvol_fd(fd);
              if (r < 0)
                      return r;
              if (!r)
                      return -ENOTTY25;

              r = btrfs_subvol_get_id_fd(fd, &subvol_id);
              if (r < 0)
                      return r;
      }

      n = btrfs_qgroup_find_parents(fd, subvol_id, &qgroups);
      if (n < 0)
              return n;
      if (n > 0) /* already parent qgroups set up, let's bail */
              return 0;

      qgroups = mfree(qgroups);

      r = btrfs_subvol_get_parent(fd, subvol_id, &parent_subvol);
      if (r == -ENXIO6)
              /* No parent, hence no qgroup memberships */
              n = 0;
      else if (r < 0)
              return r;
      else {
              n = btrfs_qgroup_find_parents(fd, parent_subvol, &qgroups);
              if (n < 0)
                      return n;
      }

      if (insert_intermediary_qgroup) {
              uint64_t lowest = 256, new_qgroupid;
              bool_Bool created = false0;
              int i;

              /* Determine the lowest qgroup that the parent
               * subvolume is assigned to. */

              for (i = 0; i < n; i++) {
                      uint64_t level;

                      r = btrfs_qgroupid_split(qgroups[i], &level, NULL((void*)0));
                      if (r < 0)
                              return r;

                      if (level < lowest)
                              lowest = level;
              }

              if (lowest <= 1) /* There are no levels left we could use insert an intermediary qgroup at */
                      return -EBUSY16;

              r = btrfs_qgroupid_make(lowest - 1, subvol_id, &new_qgroupid);
              if (r < 0)
                      return r;

              /* Create the new intermediary group, unless it already exists */
              r = btrfs_qgroup_create(fd, new_qgroupid);
              if (r < 0 && r != -EEXIST17)
                      return r;
              if (r >= 0)
                      changed = created = true1;

              for (i = 0; i < n; i++) {
                      r = btrfs_qgroup_assign(fd, new_qgroupid, qgroups[i]);
                      if (r < 0 && r != -EEXIST17) {
                              if (created)
                                      (void) btrfs_qgroup_destroy_recursive(fd, new_qgroupid);

                              return r;
                      }
                      if (r >= 0)
                              changed = true1;
              }

              r = btrfs_qgroup_assign(fd, subvol_id, new_qgroupid);
              if (r < 0 && r != -EEXIST17) {
                      if (created)
                              (void) btrfs_qgroup_destroy_recursive(fd, new_qgroupid);
                      return r;
              }
              if (r >= 0)
                      changed = true1;

      } else {
              int i;

              /* Assign our subvolume to all the same qgroups as the parent */

              for (i = 0; i < n; i++) {
                      r = btrfs_qgroup_assign(fd, subvol_id, qgroups[i]);
                      if (r < 0 && r != -EEXIST17)
                              return r;
                      if (r >= 0)
                              changed = true1;
              }
      }

      return changed;
1979}

1981int btrfs_subvol_auto_qgroup(const char *path, uint64_t subvol_id, bool_Bool create_intermediary_qgroup) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;

      fd = open(path, O_RDONLY00|O_NOCTTY0400|O_CLOEXEC02000000|O_DIRECTORY0200000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return btrfs_subvol_auto_qgroup_fd(fd, subvol_id, create_intermediary_qgroup);
1989}

1991int btrfs_subvol_get_parent(int fd, uint64_t subvol_id, uint64_t *ret) {

      struct btrfs_ioctl_search_args args = {
              /* Tree of tree roots */
              .key.tree_id = BTRFS_ROOT_TREE_OBJECTID1,

              /* Look precisely for the subvolume items */
              .key.min_type = BTRFS_ROOT_BACKREF_KEY144,
              .key.max_type = BTRFS_ROOT_BACKREF_KEY144,

              /* No restrictions on the other components */
              .key.min_offset = 0,
              .key.max_offset = (uint64_t) -1,

              .key.min_transid = 0,
              .key.max_transid = (uint64_t) -1,
      };
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/btrfs-util.c"
, 2010, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/btrfs-util.c", 2011
, __PRETTY_FUNCTION__); } while (0);

      if (subvol_id == 0) {
              r = btrfs_subvol_get_id_fd(fd, &subvol_id);
              if (r < 0)
                      return r;
      } else {
              r = btrfs_is_filesystem(fd);
              if (r < 0)
                      return r;
              if (!r)
                      return -ENOTTY25;
      }

      args.key.min_objectid = args.key.max_objectid = subvol_id;

      while (btrfs_ioctl_search_args_compare(&args) <= 0) {
              const struct btrfs_ioctl_search_header *sh;
              unsigned i;

              args.key.nr_items = 256;
              if (ioctl(fd, BTRFS_IOC_TREE_SEARCH(((2U|1U) << (((0 +8)+8)+14)) | (((0x94)) << (0 +
8)) | (((17)) << 0) | ((((sizeof(struct btrfs_ioctl_search_args
)))) << ((0 +8)+8))), &args) < 0)
                      return negative_errno();

              if (args.key.nr_items <= 0)
                      break;

              FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args)for ((i) = 0, (sh) = (const struct btrfs_ioctl_search_header*
) (args).buf; (i) < (args).key.nr_items; (i)++, (sh) = (const
 struct btrfs_ioctl_search_header*) ((uint8_t*) (sh) + sizeof
(struct btrfs_ioctl_search_header) + (sh)->len)) {

                      if (sh->type != BTRFS_ROOT_BACKREF_KEY144)
                              continue;
                      if (sh->objectid != subvol_id)
                              continue;

                      *ret = sh->offset;
                      return 0;
              }
      }

      return -ENXIO6;
2051}