From b6b1849830f5e4a6065c3b0c993668e500c954d3 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Sun, 28 Dec 2014 02:05:28 +0100 Subject: [PATCH] machined: add support for reporting image size via btrfs quota --- src/machine/image-dbus.c | 121 ++++++++++++++++++++++-- src/machine/machinectl.c | 74 +++++++++++---- src/machine/machined-dbus.c | 7 +- src/shared/btrfs-ctree.h | 23 +++++ src/shared/btrfs-util.c | 180 +++++++++++++++++++++++++++++++----- src/shared/btrfs-util.h | 8 ++ src/shared/machine-image.c | 15 +++ src/shared/machine-image.h | 5 + src/shared/missing.h | 20 ++++ src/test/test-btrfs.c | 13 ++- 10 files changed, 413 insertions(+), 53 deletions(-) diff --git a/src/machine/image-dbus.c b/src/machine/image-dbus.c index 1030cd314..cae7b227d 100644 --- a/src/machine/image-dbus.c +++ b/src/machine/image-dbus.c @@ -213,6 +213,111 @@ static int property_get_mtime( return 1; } +static int property_get_size( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + _cleanup_(image_unrefp) Image *image = NULL; + int r; + + assert(bus); + assert(reply); + + r = image_find_by_bus_path_with_error(path, &image, error); + if (r < 0) + return r; + + r = sd_bus_message_append(reply, "t", image->size); + if (r < 0) + return r; + + return 1; +} + + +static int property_get_limit( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + _cleanup_(image_unrefp) Image *image = NULL; + int r; + + assert(bus); + assert(reply); + + r = image_find_by_bus_path_with_error(path, &image, error); + if (r < 0) + return r; + + r = sd_bus_message_append(reply, "t", image->limit); + if (r < 0) + return r; + + return 1; +} + +static int property_get_size_exclusive( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + _cleanup_(image_unrefp) Image *image = NULL; + int r; + + assert(bus); + assert(reply); + + r = image_find_by_bus_path_with_error(path, &image, error); + if (r < 0) + return r; + + r = sd_bus_message_append(reply, "t", image->size_exclusive); + if (r < 0) + return r; + + return 1; +} + +static int property_get_limit_exclusive( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + _cleanup_(image_unrefp) Image *image = NULL; + int r; + + assert(bus); + assert(reply); + + r = image_find_by_bus_path_with_error(path, &image, error); + if (r < 0) + return r; + + r = sd_bus_message_append(reply, "t", image->limit_exclusive); + if (r < 0) + return r; + + return 1; +} + static int method_remove( sd_bus *bus, sd_bus_message *message, @@ -327,12 +432,16 @@ static int method_mark_read_only( const sd_bus_vtable image_vtable[] = { SD_BUS_VTABLE_START(0), - SD_BUS_PROPERTY("Name", "s", property_get_name, 0, 0), - SD_BUS_PROPERTY("Path", "s", property_get_path, 0, 0), - SD_BUS_PROPERTY("Type", "s", property_get_type, 0, 0), - SD_BUS_PROPERTY("ReadOnly", "b", property_get_read_only, 0, 0), - SD_BUS_PROPERTY("CreationTimestamp", "t", property_get_crtime, 0, 0), - SD_BUS_PROPERTY("ModificationTimestamp", "t", property_get_mtime, 0, 0), + SD_BUS_PROPERTY("Name", "s", property_get_name, 0, 0), + SD_BUS_PROPERTY("Path", "s", property_get_path, 0, 0), + SD_BUS_PROPERTY("Type", "s", property_get_type, 0, 0), + SD_BUS_PROPERTY("ReadOnly", "b", property_get_read_only, 0, 0), + SD_BUS_PROPERTY("CreationTimestamp", "t", property_get_crtime, 0, 0), + SD_BUS_PROPERTY("ModificationTimestamp", "t", property_get_mtime, 0, 0), + SD_BUS_PROPERTY("Size", "t", property_get_size, 0, 0), + SD_BUS_PROPERTY("Limit", "t", property_get_limit, 0, 0), + SD_BUS_PROPERTY("SizeExclusive", "t", property_get_size_exclusive, 0, 0), + SD_BUS_PROPERTY("LimitExclusive", "t", property_get_limit_exclusive, 0, 0), SD_BUS_METHOD("Remove", NULL, NULL, method_remove, 0), SD_BUS_METHOD("Rename", "s", NULL, method_rename, 0), SD_BUS_METHOD("Clone", "sb", NULL, method_clone, 0), diff --git a/src/machine/machinectl.c b/src/machine/machinectl.c index 893b42934..17fbe51f9 100644 --- a/src/machine/machinectl.c +++ b/src/machine/machinectl.c @@ -131,6 +131,7 @@ typedef struct ImageInfo { bool read_only; usec_t crtime; usec_t mtime; + uint64_t size; } ImageInfo; static int compare_image_info(const void *a, const void *b) { @@ -142,13 +143,13 @@ static int compare_image_info(const void *a, const void *b) { static int list_images(int argc, char *argv[], void *userdata) { _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; - size_t max_name = strlen("NAME"), max_type = strlen("TYPE"), max_crtime = strlen("CREATED"), max_mtime = strlen("MODIFIED"); + size_t max_name = strlen("NAME"), max_type = strlen("TYPE"), max_size = strlen("SIZE"), max_crtime = strlen("CREATED"), max_mtime = strlen("MODIFIED"); _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; _cleanup_free_ ImageInfo *images = NULL; size_t n_images = 0, n_allocated = 0, j; const char *name, *type, *object; sd_bus *bus = userdata; - uint64_t crtime, mtime; + uint64_t crtime, mtime, size; int read_only, r; assert(bus); @@ -169,12 +170,12 @@ static int list_images(int argc, char *argv[], void *userdata) { return r; } - r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssbtto)"); + r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssbttto)"); if (r < 0) return bus_log_parse_error(r); - while ((r = sd_bus_message_read(reply, "(ssbtto)", &name, &type, &read_only, &crtime, &mtime, &object)) > 0) { - char buf[FORMAT_TIMESTAMP_MAX]; + while ((r = sd_bus_message_read(reply, "(ssbttto)", &name, &type, &read_only, &crtime, &mtime, &size, &object)) > 0) { + char buf[MAX(FORMAT_TIMESTAMP_MAX, FORMAT_BYTES_MAX)]; size_t l; if (name[0] == '.' && !arg_all) @@ -188,6 +189,7 @@ static int list_images(int argc, char *argv[], void *userdata) { images[n_images].read_only = read_only; images[n_images].crtime = crtime; images[n_images].mtime = mtime; + images[n_images].size = size; l = strlen(name); if (l > max_name) @@ -198,17 +200,23 @@ static int list_images(int argc, char *argv[], void *userdata) { max_type = l; if (crtime != 0) { - l = strlen(format_timestamp(buf, sizeof(buf), crtime)); + l = strlen(strna(format_timestamp(buf, sizeof(buf), crtime))); if (l > max_crtime) max_crtime = l; } if (mtime != 0) { - l = strlen(format_timestamp(buf, sizeof(buf), mtime)); + l = strlen(strna(format_timestamp(buf, sizeof(buf), mtime))); if (l > max_mtime) max_mtime = l; } + if (size != (uint64_t) -1) { + l = strlen(strna(format_bytes(buf, sizeof(buf), size))); + if (l > max_size) + max_size = l; + } + n_images++; } if (r < 0) @@ -221,22 +229,24 @@ static int list_images(int argc, char *argv[], void *userdata) { qsort_safe(images, n_images, sizeof(ImageInfo), compare_image_info); if (arg_legend) - printf("%-*s %-*s %-3s %-*s %-*s\n", + printf("%-*s %-*s %-3s %-*s %-*s %-*s\n", (int) max_name, "NAME", (int) max_type, "TYPE", "RO", + (int) max_size, "SIZE", (int) max_crtime, "CREATED", (int) max_mtime, "MODIFIED"); for (j = 0; j < n_images; j++) { - char crtime_buf[FORMAT_TIMESTAMP_MAX], mtime_buf[FORMAT_TIMESTAMP_MAX]; + char crtime_buf[FORMAT_TIMESTAMP_MAX], mtime_buf[FORMAT_TIMESTAMP_MAX], size_buf[FORMAT_BYTES_MAX]; - printf("%-*s %-*s %s%-3s%s %-*s %-*s\n", + printf("%-*s %-*s %s%-3s%s %-*s %-*s %-*s\n", (int) max_name, images[j].name, (int) max_type, images[j].type, images[j].read_only ? ansi_highlight_red() : "", yes_no(images[j].read_only), images[j].read_only ? ansi_highlight_off() : "", - (int) max_crtime, images[j].crtime != 0 ? format_timestamp(crtime_buf, sizeof(crtime_buf), images[j].crtime) : "-", - (int) max_mtime, images[j].mtime != 0 ? format_timestamp(mtime_buf, sizeof(mtime_buf), images[j].mtime) : "-"); + (int) max_size, strna(format_bytes(size_buf, sizeof(size_buf), images[j].size)), + (int) max_crtime, strna(format_timestamp(crtime_buf, sizeof(crtime_buf), images[j].crtime)), + (int) max_mtime, strna(format_timestamp(mtime_buf, sizeof(mtime_buf), images[j].mtime))); } if (r < 0) @@ -651,11 +661,17 @@ typedef struct ImageStatusInfo { int read_only; usec_t crtime; usec_t mtime; + uint64_t size; + uint64_t limit; + uint64_t size_exclusive; + uint64_t limit_exclusive; } ImageStatusInfo; static void print_image_status_info(sd_bus *bus, ImageStatusInfo *i) { char ts_relative[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1; char ts_absolute[FORMAT_TIMESTAMP_MAX], *s2; + char bs[FORMAT_BYTES_MAX], *s3; + char bs_exclusive[FORMAT_BYTES_MAX], *s4; assert(bus); assert(i); @@ -678,28 +694,46 @@ static void print_image_status_info(sd_bus *bus, ImageStatusInfo *i) { s1 = format_timestamp_relative(ts_relative, sizeof(ts_relative), i->crtime); s2 = format_timestamp(ts_absolute, sizeof(ts_absolute), i->crtime); - if (s1) + if (s1 && s2) printf("\t Created: %s; %s\n", s2, s1); else if (s2) printf("\t Created: %s\n", s2); s1 = format_timestamp_relative(ts_relative, sizeof(ts_relative), i->mtime); s2 = format_timestamp(ts_absolute, sizeof(ts_absolute), i->mtime); - if (s1) + if (s1 && s2) printf("\tModified: %s; %s\n", s2, s1); else if (s2) printf("\tModified: %s\n", s2); + + s3 = format_bytes(bs, sizeof(bs), i->size); + s4 = i->size_exclusive != i->size ? format_bytes(bs_exclusive, sizeof(bs_exclusive), i->size_exclusive) : NULL; + if (s3 && s4) + printf("\t Size: %s (exclusive: %s)\n", s3, s4); + else if (s3) + printf("\t Size: %s\n", s3); + + s3 = format_bytes(bs, sizeof(bs), i->limit); + s4 = i->limit_exclusive != i->limit ? format_bytes(bs_exclusive, sizeof(bs_exclusive), i->limit_exclusive) : NULL; + if (s3 && s4) + printf("\t Limit: %s (exclusive: %s)\n", s3, s4); + else if (s3) + printf("\t Limit: %s\n", s3); } static int show_image_info(const char *verb, sd_bus *bus, const char *path, bool *new_line) { static const struct bus_properties_map map[] = { - { "Name", "s", NULL, offsetof(ImageStatusInfo, name) }, - { "Path", "s", NULL, offsetof(ImageStatusInfo, path) }, - { "Type", "s", NULL, offsetof(ImageStatusInfo, type) }, - { "ReadOnly", "b", NULL, offsetof(ImageStatusInfo, read_only) }, - { "CreationTimestamp", "t", NULL, offsetof(ImageStatusInfo, crtime) }, - { "ModificationTimestamp", "t", NULL, offsetof(ImageStatusInfo, mtime) }, + { "Name", "s", NULL, offsetof(ImageStatusInfo, name) }, + { "Path", "s", NULL, offsetof(ImageStatusInfo, path) }, + { "Type", "s", NULL, offsetof(ImageStatusInfo, type) }, + { "ReadOnly", "b", NULL, offsetof(ImageStatusInfo, read_only) }, + { "CreationTimestamp", "t", NULL, offsetof(ImageStatusInfo, crtime) }, + { "ModificationTimestamp", "t", NULL, offsetof(ImageStatusInfo, mtime) }, + { "Size", "t", NULL, offsetof(ImageStatusInfo, size) }, + { "Limit", "t", NULL, offsetof(ImageStatusInfo, limit) }, + { "SizeExclusive", "t", NULL, offsetof(ImageStatusInfo, size_exclusive) }, + { "LimitExclusive", "t", NULL, offsetof(ImageStatusInfo, limit_exclusive) }, {} }; diff --git a/src/machine/machined-dbus.c b/src/machine/machined-dbus.c index 18b772d42..8bb0146f5 100644 --- a/src/machine/machined-dbus.c +++ b/src/machine/machined-dbus.c @@ -489,7 +489,7 @@ static int method_list_images(sd_bus *bus, sd_bus_message *message, void *userda if (r < 0) return r; - r = sd_bus_message_open_container(reply, 'a', "(ssbtto)"); + r = sd_bus_message_open_container(reply, 'a', "(ssbttto)"); if (r < 0) return r; @@ -500,12 +500,13 @@ static int method_list_images(sd_bus *bus, sd_bus_message *message, void *userda if (!p) return -ENOMEM; - r = sd_bus_message_append(reply, "(ssbtto)", + r = sd_bus_message_append(reply, "(ssbttto)", image->name, image_type_to_string(image->type), image->read_only, image->crtime, image->mtime, + image->size, p); if (r < 0) return r; @@ -678,7 +679,7 @@ const sd_bus_vtable manager_vtable[] = { SD_BUS_METHOD("GetImage", "s", "o", method_get_image, SD_BUS_VTABLE_UNPRIVILEGED), SD_BUS_METHOD("GetMachineByPID", "u", "o", method_get_machine_by_pid, SD_BUS_VTABLE_UNPRIVILEGED), SD_BUS_METHOD("ListMachines", NULL, "a(ssso)", method_list_machines, SD_BUS_VTABLE_UNPRIVILEGED), - SD_BUS_METHOD("ListImages", NULL, "a(ssbtto)", method_list_images, SD_BUS_VTABLE_UNPRIVILEGED), + SD_BUS_METHOD("ListImages", NULL, "a(ssbttto)", method_list_images, SD_BUS_VTABLE_UNPRIVILEGED), SD_BUS_METHOD("CreateMachine", "sayssusa(sv)", "o", method_create_machine, 0), SD_BUS_METHOD("CreateMachineWithNetwork", "sayssusaia(sv)", "o", method_create_machine_with_network, 0), SD_BUS_METHOD("RegisterMachine", "sayssus", "o", method_register_machine, 0), diff --git a/src/shared/btrfs-ctree.h b/src/shared/btrfs-ctree.h index 45b94cdbf..7bdf3fe13 100644 --- a/src/shared/btrfs-ctree.h +++ b/src/shared/btrfs-ctree.h @@ -66,3 +66,26 @@ struct btrfs_root_item { } _packed_; #define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0) + +struct btrfs_qgroup_info_item { + le64_t generation; + le64_t rfer; + le64_t rfer_cmpr; + le64_t excl; + le64_t excl_cmpr; +} _packed_; + +#define BTRFS_QGROUP_LIMIT_MAX_RFER (1ULL << 0) +#define BTRFS_QGROUP_LIMIT_MAX_EXCL (1ULL << 1) +#define BTRFS_QGROUP_LIMIT_RSV_RFER (1ULL << 2) +#define BTRFS_QGROUP_LIMIT_RSV_EXCL (1ULL << 3) +#define BTRFS_QGROUP_LIMIT_RFER_CMPR (1ULL << 4) +#define BTRFS_QGROUP_LIMIT_EXCL_CMPR (1ULL << 5) + +struct btrfs_qgroup_limit_item { + le64_t flags; + le64_t max_rfer; + le64_t max_excl; + le64_t rsv_rfer; + le64_t rsv_excl; +} _packed_; diff --git a/src/shared/btrfs-util.c b/src/shared/btrfs-util.c index 9b47330a6..164ac9f33 100644 --- a/src/shared/btrfs-util.c +++ b/src/shared/btrfs-util.c @@ -341,7 +341,7 @@ int btrfs_subvol_get_id_fd(int fd, uint64_t *ret) { int btrfs_subvol_get_info_fd(int fd, BtrfsSubvolInfo *ret) { struct btrfs_ioctl_search_args args = { /* Tree of tree roots */ - .key.tree_id = 1, + .key.tree_id = BTRFS_ROOT_TREE_OBJECTID, /* Look precisely for the subvolume items */ .key.min_type = BTRFS_ROOT_ITEM_KEY, @@ -352,14 +352,10 @@ int btrfs_subvol_get_info_fd(int fd, BtrfsSubvolInfo *ret) { .key.max_offset = (uint64_t) -1, .key.min_transid = 0, .key.max_transid = (uint64_t) -1, - - /* Some large value */ - .key.nr_items = 2, }; - struct btrfs_ioctl_search_header *sh; - struct btrfs_root_item *ri; uint64_t subvol_id; + bool found = false; int r; assert(fd >= 0); @@ -370,30 +366,168 @@ int btrfs_subvol_get_info_fd(int fd, BtrfsSubvolInfo *ret) { return r; args.key.min_objectid = args.key.max_objectid = subvol_id; - if (ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args) < 0) - return -errno; - if (args.key.nr_items != 1) - return -EIO; + for (;;) { + 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; - sh = (struct btrfs_ioctl_search_header*) args.buf; - assert(sh->type == BTRFS_ROOT_ITEM_KEY); - assert(sh->objectid == subvol_id); + for (i = 0, + sh = (const struct btrfs_ioctl_search_header*) args.buf; + i < args.key.nr_items; + i++, + args.key.min_type = sh->type, + args.key.min_offset = sh->offset, + args.key.min_objectid = sh->objectid, + sh = (const struct btrfs_ioctl_search_header*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header) + sh->len)) { - if (sh->len < offsetof(struct btrfs_root_item, otime) + sizeof(struct btrfs_timespec)) - return -ENOTSUP; + const struct btrfs_root_item *ri; + + if (sh->objectid != subvol_id) + continue; + if (sh->type != BTRFS_ROOT_ITEM_KEY) + continue; + if (sh->len < offsetof(struct btrfs_root_item, otime) + sizeof(struct btrfs_timespec)) + continue; - ri = (struct btrfs_root_item *)(args.buf + sizeof(struct btrfs_ioctl_search_header)); + ri = (const struct btrfs_root_item *)(args.buf + sizeof(struct btrfs_ioctl_search_header)); - ret->otime = (usec_t) le64toh(ri->otime.sec) * USEC_PER_SEC + - (usec_t) le32toh(ri->otime.nsec) / NSEC_PER_USEC; + 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); + 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)); + 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; + } + + args.key.min_offset++; + if (!args.key.min_offset) /* overflow */ + break; + } + +finish: + if (!found) + return -ENODATA; + + return 0; +} + +int btrfs_subvol_get_quota_fd(int fd, BtrfsQuotaInfo *ret) { + + struct btrfs_ioctl_search_args args = { + /* Tree of quota items */ + .key.tree_id = BTRFS_QUOTA_TREE_OBJECTID, + + /* Look precisely for the quota items */ + .key.min_type = BTRFS_QGROUP_STATUS_KEY, + .key.max_type = BTRFS_QGROUP_LIMIT_KEY, + + .key.min_objectid = 0, + .key.max_objectid = 0, + + /* No restrictions on the other components */ + .key.min_transid = 0, + .key.max_transid = (uint64_t) -1, + }; + + uint64_t subvol_id; + bool found_info = false, found_limit = false; + int r; + + assert(fd >= 0); + assert(ret); + + r = btrfs_subvol_get_id_fd(fd, &subvol_id); + if (r < 0) + return r; + + args.key.min_offset = args.key.max_offset = subvol_id; + + for (;;) { + 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; + + for (i = 0, + sh = (const struct btrfs_ioctl_search_header*) args.buf; + i < args.key.nr_items; + i++, + args.key.min_type = sh->type, + args.key.min_offset = sh->offset, + args.key.min_objectid = sh->objectid, + sh = (const struct btrfs_ioctl_search_header*) ((uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header) + sh->len)) { + + const void *body; + + if (sh->objectid != 0) + continue; + if (sh->offset != subvol_id) + continue; + + body = (uint8_t*) sh + sizeof(struct btrfs_ioctl_search_header); + + if (sh->type == BTRFS_QGROUP_INFO_KEY) { + const struct btrfs_qgroup_info_item *qii = body; + + ret->referred = 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 = body; + + ret->referred_max = le64toh(qli->max_rfer); + ret->exclusive_max = le64toh(qli->max_excl); + + if (ret->referred_max == 0) + ret->referred_max = (uint64_t) -1; + if (ret->exclusive_max == 0) + ret->exclusive_max = (uint64_t) -1; + + found_limit = true; + } + + if (found_info && found_limit) + goto finish; + } + + args.key.min_offset++; + if (!args.key.min_offset) + break; + } + +finish: + if (!found_limit && !found_info) + return -ENODATA; + + if (!found_info) { + ret->referred = (uint64_t) -1; + ret->exclusive = (uint64_t) -1; + } + + if (!found_limit) { + ret->referred_max = (uint64_t) -1; + ret->exclusive_max = (uint64_t) -1; + } return 0; } diff --git a/src/shared/btrfs-util.h b/src/shared/btrfs-util.h index dff8c015a..1532c120d 100644 --- a/src/shared/btrfs-util.h +++ b/src/shared/btrfs-util.h @@ -34,6 +34,13 @@ typedef struct BtrfsSubvolInfo { bool read_only; } BtrfsSubvolInfo; +typedef struct BtrfsQuotaInfo { + uint64_t referred; + uint64_t exclusive; + uint64_t referred_max; + uint64_t exclusive_max; +} BtrfsQuotaInfo; + int btrfs_is_snapshot(int fd); int btrfs_subvol_make(const char *path); @@ -45,6 +52,7 @@ int btrfs_subvol_set_read_only(const char *path, bool b); int btrfs_subvol_get_read_only_fd(int fd); int btrfs_subvol_get_id_fd(int fd, uint64_t *ret); int btrfs_subvol_get_info_fd(int fd, BtrfsSubvolInfo *info); +int btrfs_subvol_get_quota_fd(int fd, BtrfsQuotaInfo *quota); int btrfs_reflink(int infd, int outfd); diff --git a/src/shared/machine-image.c b/src/shared/machine-image.c index 7c041fab7..36b64e1fa 100644 --- a/src/shared/machine-image.c +++ b/src/shared/machine-image.c @@ -71,6 +71,8 @@ static int image_new( i->read_only = read_only; i->crtime = crtime; i->mtime = mtime; + i->size = i->size_exclusive = (uint64_t) -1; + i->limit = i->limit_exclusive = (uint64_t) -1; i->name = strdup(pretty); if (!i->name) @@ -138,6 +140,7 @@ static int image_make( if (F_TYPE_EQUAL(sfs.f_type, BTRFS_SUPER_MAGIC)) { BtrfsSubvolInfo info; + BtrfsQuotaInfo quota; /* It's a btrfs subvolume */ @@ -156,6 +159,15 @@ static int image_make( if (r < 0) return r; + r = btrfs_subvol_get_quota_fd(fd, "a); + if (r >= 0) { + (*ret)->size = quota.referred; + (*ret)->size_exclusive = quota.exclusive; + + (*ret)->limit = quota.referred_max; + (*ret)->limit_exclusive = quota.exclusive_max; + } + return 1; } } @@ -199,6 +211,9 @@ static int image_make( if (r < 0) return r; + (*ret)->size = (*ret)->size_exclusive = st.st_blocks * 512; + (*ret)->limit = (*ret)->limit_exclusive = st.st_size; + return 1; } diff --git a/src/shared/machine-image.h b/src/shared/machine-image.h index 9e0f6aedb..10e5d0a53 100644 --- a/src/shared/machine-image.h +++ b/src/shared/machine-image.h @@ -40,6 +40,11 @@ typedef struct Image { usec_t crtime; usec_t mtime; + + uint64_t size; + uint64_t size_exclusive; + uint64_t limit; + uint64_t limit_exclusive; } Image; Image *image_unref(Image *i); diff --git a/src/shared/missing.h b/src/shared/missing.h index 08cf83647..94d9d8d35 100644 --- a/src/shared/missing.h +++ b/src/shared/missing.h @@ -254,10 +254,30 @@ struct btrfs_ioctl_fs_info_args { #define BTRFS_FIRST_FREE_OBJECTID 256 #endif +#ifndef BTRFS_ROOT_TREE_OBJECTID +#define BTRFS_ROOT_TREE_OBJECTID 1 +#endif + +#ifndef BTRFS_QUOTA_TREE_OBJECTID +#define BTRFS_QUOTA_TREE_OBJECTID 8ULL +#endif + #ifndef BTRFS_ROOT_ITEM_KEY #define BTRFS_ROOT_ITEM_KEY 132 #endif +#ifndef BTRFS_QGROUP_STATUS_KEY +#define BTRFS_QGROUP_STATUS_KEY 240 +#endif + +#ifndef BTRFS_QGROUP_INFO_KEY +#define BTRFS_QGROUP_INFO_KEY 242 +#endif + +#ifndef BTRFS_QGROUP_LIMIT_KEY +#define BTRFS_QGROUP_LIMIT_KEY 244 +#endif + #ifndef BTRFS_SUPER_MAGIC #define BTRFS_SUPER_MAGIC 0x9123683E #endif diff --git a/src/test/test-btrfs.c b/src/test/test-btrfs.c index 43b445d83..150a32ad6 100644 --- a/src/test/test-btrfs.c +++ b/src/test/test-btrfs.c @@ -36,7 +36,8 @@ int main(int argc, char *argv[]) { log_error_errno(errno, "Failed to open root directory: %m"); else { BtrfsSubvolInfo info; - char ts[FORMAT_TIMESTAMP_MAX]; + BtrfsQuotaInfo quota; + char ts[FORMAT_TIMESTAMP_MAX], bs[FORMAT_BYTES_MAX]; r = btrfs_subvol_get_info_fd(fd, &info); if (r < 0) @@ -46,6 +47,16 @@ int main(int argc, char *argv[]) { log_info("read-only (search): %s", yes_no(info.read_only)); } + r = btrfs_subvol_get_quota_fd(fd, "a); + if (r < 0) + log_error_errno(r, "Failed to get quota info: %m"); + else { + log_info("referred: %s", strna(format_bytes(bs, sizeof(bs), quota.referred))); + log_info("exclusive: %s", strna(format_bytes(bs, sizeof(bs), quota.exclusive))); + log_info("referred_max: %s", strna(format_bytes(bs, sizeof(bs), quota.referred_max))); + log_info("exclusive_max: %s", strna(format_bytes(bs, sizeof(bs), quota.exclusive_max))); + } + r = btrfs_subvol_get_read_only_fd(fd); if (r < 0) log_error_errno(r, "Failed to get read only flag: %m"); -- 2.30.2