#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <linux/btrfs_tree.h>

#include <linux/fs.h>

#include <linux/loop.h>

#include <linux/magic.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/ioctl.h>

#include <sys/sysmacros.h>

#include <unistd.h>

#include "alloc-util.h"

#include "blockdev-util.h"

#include "btrfs-util.h"

#include "chattr-util.h"

#include "copy.h"

#include "fd-util.h"

#include "fileio.h"

#include "fs-util.h"

#include "io-util.h"

#include "macro.h"

#include "path-util.h"

#include "rm-rf.h"

#include "smack-util.h"

#include "sparse-endian.h"

#include "stat-util.h"

#include "string-util.h"

#include "time-util.h"

#include "util.h"

static int validate_subvolume_name(const char *name) {

if (!filename_is_valid(name))

return -EINVAL;

if (strlen(name) > BTRFS_SUBVOL_NAME_MAX)

return -E2BIG;

return 0;

}

static int extract_subvolume_name(const char *path, const char **subvolume) {

const char *fn;

int r;

assert(path);

assert(subvolume);

fn = basename(path);

r = validate_subvolume_name(fn);

if (r < 0)

return r;

*subvolume = fn;

return 0;

}

int btrfs_is_subvol_fd(int fd) {

struct stat st;

assert(fd >= 0);

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

if (fstat(fd, &st) < 0)

return -errno;

if (!btrfs_might_be_subvol(&st))

return 0;

return fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

}

int btrfs_is_subvol(const char *path) {

_cleanup_close_ int fd = -1;

assert(path);

fd = open(path, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);

if (fd < 0)

return -errno;

return btrfs_is_subvol_fd(fd);

}

int btrfs_subvol_make_fd(int fd, const char *subvolume) {

struct btrfs_ioctl_vol_args args = {};

_cleanup_close_ int real_fd = -1;

int r;

assert(subvolume);

r = validate_subvolume_name(subvolume);

if (r < 0)

return r;

r = fcntl(fd, F_GETFL);

if (r < 0)

return -errno;

if (FLAGS_SET(r, O_PATH)) {

/* An O_PATH fd was specified, let's convert here to a proper one, as btrfs ioctl's can't deal with

real_fd = fd_reopen(fd, O_RDONLY|O_CLOEXEC|O_DIRECTORY);

if (real_fd < 0)

return real_fd;

fd = real_fd;

}

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

return RET_NERRNO(ioctl(fd, BTRFS_IOC_SUBVOL_CREATE, &args));

}

int btrfs_subvol_make(const char *path) {

_cleanup_close_ int fd = -1;

const char *subvolume;

int r;

assert(path);

r = extract_subvolume_name(path, &subvolume);

if (r < 0)

return r;

fd = open_parent(path, O_CLOEXEC, 0);

if (fd < 0)

return fd;

return btrfs_subvol_make_fd(fd, subvolume);

}

int btrfs_subvol_make_fallback(const char *path, mode_t mode) {

mode_t old, combined;

int r;

assert(path);

/* Let's work like mkdir(), i.e. take the specified mode, and mask it with the current umask. */

old = umask(~mode);

combined = old | ~mode;

if (combined != ~mode)

umask(combined);

r = btrfs_subvol_make(path);

umask(old);

if (r >= 0)

return 1; /* subvol worked */

if (r != -ENOTTY)

return r;

if (mkdir(path, mode) < 0)

return -errno;

return 0; /* plain directory */

}

int btrfs_subvol_set_read_only_fd(int fd, bool b) {

uint64_t flags, nflags;

struct stat st;

assert(fd >= 0);

if (fstat(fd, &st) < 0)

return -errno;

if (!btrfs_might_be_subvol(&st))

return -EINVAL;

if (ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags) < 0)

return -errno;

nflags = UPDATE_FLAG(flags, BTRFS_SUBVOL_RDONLY, b);

if (flags == nflags)

return 0;

return RET_NERRNO(ioctl(fd, BTRFS_IOC_SUBVOL_SETFLAGS, &nflags));

}

int btrfs_subvol_set_read_only(const char *path, bool b) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);

if (fd < 0)

return -errno;

return btrfs_subvol_set_read_only_fd(fd, b);

}

int btrfs_subvol_get_read_only_fd(int fd) {

uint64_t flags;

struct stat st;

assert(fd >= 0);

if (fstat(fd, &st) < 0)

return -errno;

if (!btrfs_might_be_subvol(&st))

return -EINVAL;

if (ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags) < 0)

return -errno;

return !!(flags & BTRFS_SUBVOL_RDONLY);

}

int btrfs_reflink(int infd, int outfd) {

int r;

assert(infd >= 0);

assert(outfd >= 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;

return RET_NERRNO(ioctl(outfd, BTRFS_IOC_CLONE, infd));

}

int 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);

assert(outfd >= 0);

assert(sz > 0);

r = fd_verify_regular(outfd);

if (r < 0)

return r;

return RET_NERRNO(ioctl(outfd, BTRFS_IOC_CLONE_RANGE, &args));

}

int 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);

assert(dev);

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (!r)

return -ENOTTY;

if (ioctl(fd, BTRFS_IOC_FS_INFO, &fsi) < 0)

return -errno;

/* 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, &di) < 0) {

if (errno == ENODEV)

continue;

return -errno;

}

/* For the root fs — when no initrd is involved — btrfs returns /dev/root on any kernels from

if (path_equal((char*) di.path, "/dev/root"))

return -EUCLEAN;

if (stat((char*) di.path, &st) < 0)

return -errno;

if (!S_ISBLK(st.st_mode))

return -ENOTBLK;

if (major(st.st_rdev) == 0)

return -ENODEV;

*dev = st.st_rdev;

return 1;

}

return -ENODEV;

}

int btrfs_get_block_device(const char *path, dev_t *dev) {

_cleanup_close_ int fd = -1;

assert(path);

assert(dev);

fd = open(path, O_RDONLY|O_NOCTTY|O_CLOEXEC);

if (fd < 0)

return -errno;

return btrfs_get_block_device_fd(fd, dev);

}

int btrfs_subvol_get_id_fd(int fd, uint64_t *ret) {

struct btrfs_ioctl_ino_lookup_args args = {

.objectid = BTRFS_FIRST_FREE_OBJECTID

};

int r;

assert(fd >= 0);

assert(ret);

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (!r)

return -ENOTTY;

if (ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args) < 0)

return -errno;

*ret = args.treeid;

return 0;

}

int btrfs_subvol_get_id(int fd, const char *subvol, uint64_t *ret) {

_cleanup_close_ int subvol_fd = -1;

assert(fd >= 0);

assert(ret);

subvol_fd = openat(fd, subvol, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (subvol_fd < 0)

return -errno;

return btrfs_subvol_get_id_fd(subvol_fd, ret);

}

static bool btrfs_ioctl_search_args_inc(struct btrfs_ioctl_search_args *args) {

assert(args);

/* the objectid, type, offset together make up the btrfs key,

if (args->key.min_offset < UINT64_MAX) {

args->key.min_offset++;

return true;

}

if (args->key.min_type < UINT8_MAX) {

args->key.min_type++;

args->key.min_offset = 0;

return true;

}

if (args->key.min_objectid < UINT64_MAX) {

args->key.min_objectid++;

args->key.min_offset = 0;

args->key.min_type = 0;

return true;

}

return 0;

}

static void btrfs_ioctl_search_args_set(struct btrfs_ioctl_search_args *args, const struct btrfs_ioctl_search_header *h) {

assert(args);

assert(h);

args->key.min_objectid = h->objectid;

args->key.min_type = h->type;

args->key.min_offset = h->offset;

}

static int btrfs_ioctl_search_args_compare(const struct btrfs_ioctl_search_args *args) {

int r;

assert(args);

/* Compare min and max */

r = CMP(args->key.min_objectid, args->key.max_objectid);

if (r != 0)

return r;

r = CMP(args->key.min_type, args->key.max_type);

if (r != 0)

return r;

return CMP(args->key.min_offset, args->key.max_offset);

}

#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))

#define BTRFS_IOCTL_SEARCH_HEADER_BODY(sh) \

((void*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header)))

int 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_OBJECTID,

/* Look precisely for the subvolume items */

.key.min_type = BTRFS_ROOT_ITEM_KEY,

.key.max_type = BTRFS_ROOT_ITEM_KEY,

.key.min_offset = 0,

.key.max_offset = UINT64_MAX,

/* No restrictions on the other components */

.key.min_transid = 0,

.key.max_transid = UINT64_MAX,

};

bool found = false;

int r;

assert(fd >= 0);

assert(ret);

if (subvol_id == 0) {

r = btrfs_subvol_get_id_fd(fd, &subvol_id);

if (r < 0)

return r;

} else {

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (!r)

return -ENOTTY;

}

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, &args) < 0)

return -errno;

if (args.key.nr_items <= 0)

break;

FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args) {

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_KEY)

continue;

/* Older versions of the struct lacked the otime setting */

if (sh->len < offsetof(struct btrfs_root_item, otime) + sizeof(struct btrfs_timespec))

continue;

ri = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh);

ret->otime = (usec_t) le64toh(ri->otime.sec) * USEC_PER_SEC +

(usec_t) le32toh(ri->otime.nsec) / NSEC_PER_USEC;

ret->subvol_id = subvol_id;

ret->read_only = le64toh(ri->flags) & BTRFS_ROOT_SUBVOL_RDONLY;

assert_cc(sizeof(ri->uuid) == sizeof(ret->uuid));

memcpy(&ret->uuid, ri->uuid, sizeof(ret->uuid));

memcpy(&ret->parent_uuid, ri->parent_uuid, sizeof(ret->parent_uuid));

found = true;

goto finish;

}

/* Increase search key by one, to read the next item, if we can. */

if (!btrfs_ioctl_search_args_inc(&args))

break;

}

finish:

if (!found)

return -ENODATA;

return 0;

}

int 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_OBJECTID,

/* 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_KEY,

.key.max_type = BTRFS_QGROUP_LIMIT_KEY,

/* No restrictions on the other components */

.key.min_transid = 0,

.key.max_transid = UINT64_MAX,

};

bool found_info = false, found_limit = false;

int r;

assert(fd >= 0);

assert(ret);

if (qgroupid == 0) {

r = btrfs_subvol_get_id_fd(fd, &qgroupid);

if (r < 0)

return r;

} else {

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (!r)

return -ENOTTY;

}

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, &args) < 0) {

if (errno == ENOENT) /* quota tree is missing: quota disabled */

break;

return -errno;

}

if (args.key.nr_items <= 0)

break;

FOREACH_BTRFS_IOCTL_SEARCH_HEADER(i, sh, args) {

/* 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_KEY) {

const struct btrfs_qgroup_info_item *qii = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh);

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

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

found_info = true;

} else if (sh->type == BTRFS_QGROUP_LIMIT_KEY) {

const struct btrfs_qgroup_limit_item *qli = BTRFS_IOCTL_SEARCH_HEADER_BODY(sh);

if (le64toh(qli->flags) & BTRFS_QGROUP_LIMIT_MAX_RFER)

ret->referenced_max = le64toh(qli->max_rfer);

else

ret->referenced_max = UINT64_MAX;

if (le64toh(qli->flags) & BTRFS_QGROUP_LIMIT_MAX_EXCL)

ret->exclusive_max = le64toh(qli->max_excl);

else

ret->exclusive_max = UINT64_MAX;

found_limit = true;

}

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;

}

finish:

if (!found_limit && !found_info)

return -ENODATA;

if (!found_info) {

ret->referenced = UINT64_MAX;

ret->exclusive = UINT64_MAX;

}

if (!found_limit) {

ret->referenced_max = UINT64_MAX;

ret->exclusive_max = UINT64_MAX;

}

return 0;

}

int btrfs_qgroup_get_quota(const char *path, uint64_t qgroupid, BtrfsQuotaInfo *ret) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (fd < 0)

return -errno;

return btrfs_qgroup_get_quota_fd(fd, qgroupid, ret);

}

int btrfs_subvol_find_subtree_qgroup(int fd, uint64_t subvol_id, uint64_t *ret) {

uint64_t level, lowest = UINT64_MAX, lowest_qgroupid = 0;

_cleanup_free_ uint64_t *qgroups = NULL;

int r, n;

assert(fd >= 0);

assert(ret);

/* This finds the "subtree" qgroup for a specific

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);

if (r < 0)

return r;

if (level != 0) /* Input must be a leaf qgroup */

return -EINVAL;

n = btrfs_qgroup_find_parents(fd, subvol_id, &qgroups);

if (n < 0)

return n;

for (int 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_MAX || level < lowest) {

lowest_qgroupid = qgroups[i];

lowest = level;

}

}

if (lowest == UINT64_MAX) {

/* No suitable higher-level qgroup found, let's return

*ret = subvol_id;

return 0;

}

*ret = lowest_qgroupid;

return 1;

}

int btrfs_subvol_get_subtree_quota_fd(int fd, uint64_t subvol_id, BtrfsQuotaInfo *ret) {

uint64_t qgroupid;

int r;

assert(fd >= 0);

assert(ret);

/* This determines the quota data of the qgroup with the

r = btrfs_subvol_find_subtree_qgroup(fd, subvol_id, &qgroupid);

if (r < 0)

return r;

return btrfs_qgroup_get_quota_fd(fd, qgroupid, ret);

}

int btrfs_subvol_get_subtree_quota(const char *path, uint64_t subvol_id, BtrfsQuotaInfo *ret) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (fd < 0)

return -errno;

return btrfs_subvol_get_subtree_quota_fd(fd, subvol_id, ret);

}

int btrfs_defrag(const char *p) {

_cleanup_close_ int fd = -1;

fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (fd < 0)

return -errno;

return btrfs_defrag_fd(fd);

}

int btrfs_quota_enable_fd(int fd, bool b) {

struct btrfs_ioctl_quota_ctl_args args = {

.cmd = b ? BTRFS_QUOTA_CTL_ENABLE : BTRFS_QUOTA_CTL_DISABLE,

};

int r;

assert(fd >= 0);

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (!r)

return -ENOTTY;

return RET_NERRNO(ioctl(fd, BTRFS_IOC_QUOTA_CTL, &args));

}

int btrfs_quota_enable(const char *path, bool b) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (fd < 0)

return -errno;

return btrfs_quota_enable_fd(fd, b);

}

int 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,

};

int r;

assert(fd >= 0);

if (qgroupid == 0) {

r = btrfs_subvol_get_id_fd(fd, &qgroupid);

if (r < 0)

return r;

} else {

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (!r)

return -ENOTTY;

}

args.qgroupid = qgroupid;

for (unsigned c = 0;; c++) {

if (ioctl(fd, BTRFS_IOC_QGROUP_LIMIT, &args) < 0) {

if (errno == EBUSY && c < 10) {

(void) btrfs_quota_scan_wait(fd);

continue;

}

return -errno;

}

break;

}

return 0;

}

int btrfs_qgroup_set_limit(const char *path, uint64_t qgroupid, uint64_t referenced_max) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (fd < 0)

return -errno;

return btrfs_qgroup_set_limit_fd(fd, qgroupid, referenced_max);

}

int 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);

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);

}

int btrfs_subvol_set_subtree_quota_limit(const char *path, uint64_t subvol_id, uint64_t referenced_max) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);

if (fd < 0)

return -errno;

return btrfs_subvol_set_subtree_quota_limit_fd(fd, subvol_id, referenced_max);

}

int btrfs_qgroupid_make(uint64_t level, uint64_t id, uint64_t *ret) {

assert(ret);

if (level >= (UINT64_C(1) << (64 - BTRFS_QGROUP_LEVEL_SHIFT)))

return -EINVAL;

if (id >= (UINT64_C(1) << BTRFS_QGROUP_LEVEL_SHIFT))

return -EINVAL;

*ret = (level << BTRFS_QGROUP_LEVEL_SHIFT) | id;

return 0;

}

int btrfs_qgroupid_split(uint64_t qgroupid, uint64_t *level, uint64_t *id) {

assert(level || id);

if (level)

*level = qgroupid >> BTRFS_QGROUP_LEVEL_SHIFT;

if (id)

*id = qgroupid & ((UINT64_C(1) << BTRFS_QGROUP_LEVEL_SHIFT) - 1);

return 0;

}

static int qgroup_create_or_destroy(int fd, bool b, uint64_t qgroupid) {

struct btrfs_ioctl_qgroup_create_args args = {

.create = b,

.qgroupid = qgroupid,

};

int r;

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;

if (r == 0)

return -ENOTTY;

for (unsigned c = 0;; c++) {

if (ioctl(fd, BTRFS_IOC_QGROUP_CREATE, &args) < 0) {

/* On old kernels if quota is not enabled, we get EINVAL. On newer kernels we get

if (IN_SET(errno, EINVAL, ENOTCONN))

return -ENOTCONN;

if (errno == EBUSY && c < 10) {

(void) btrfs_quota_scan_wait(fd);

continue;

}

return -errno;

}

break;

}

return 0;

}

int btrfs_qgroup_create(int fd, uint64_t qgroupid) {

return qgroup_create_or_destroy(fd, true, qgroupid);

}

int btrfs_qgroup_destroy(int fd, uint64_t qgroupid) {

return qgroup_create_or_destroy(fd, false, qgroupid);

}

int btrfs_qgroup_destroy_recursive(int fd, uint64_t qgroupid) {

_cleanup_free_ uint64_t *qgroups = NULL;

uint64_t subvol_id;

int n, r;

/* Destroys the specified qgroup, but unassigns it from all

r = btrfs_qgroupid_split(qgroupid, NULL, &subvol_id);

if (r < 0)

return r;

n = btrfs_qgroup_find_parents(fd, qgroupid, &qgroups);

if (n < 0)

return n;

for (int i = 0; i < n; i++) {

uint64_t id;

r = btrfs_qgroupid_split(qgroups[i], NULL, &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

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

}

return btrfs_qgroup_destroy(fd, qgroupid);

}

int btrfs_quota_scan_start(int fd) {

struct btrfs_ioctl_quota_rescan_args args = {};

assert(fd >= 0);

return RET_NERRNO(ioctl(fd, BTRFS_IOC_QUOTA_RESCAN, &args));

}

int btrfs_quota_scan_wait(int fd) {

assert(fd >= 0);

return RET_NERRNO(ioctl(fd, BTRFS_IOC_QUOTA_RESCAN_WAIT));

}

int btrfs_quota_scan_ongoing(int fd) {

struct btrfs_ioctl_quota_rescan_args args = {};

assert(fd >= 0);

if (ioctl(fd, BTRFS_IOC_QUOTA_RESCAN_STATUS, &args) < 0)

return -errno;

return !!args.flags;

}

static int qgroup_assign_or_unassign(int fd, bool b, uint64_t child, uint64_t parent) {

struct btrfs_ioctl_qgroup_assign_args args = {

.assign = b,

.src = child,

.dst = parent,

};

int r;

r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);

if (r < 0)

return r;