machined: add support for reporting image size via btrfs quota

10 files changed, 413 insertions, 53 deletions

diff --git a/src/machine/image-dbus.c b/src/machine/image-dbus.c
index 1030cd314f..cae7b227dd 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 893b429342..17fbe51f9f 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 18b772d42d..8bb0146f50 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 45b94cdbf6..7bdf3fe139 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 9b47330a6f..164ac9f337 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 dff8c015a6..1532c120df 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 7c041fab76..36b64e1fab 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, &quota);
+                                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 9e0f6aedba..10e5d0a533 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 08cf83647d..94d9d8d35d 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 43b445d831..150a32ad6f 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, &quota);
+                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");