shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-12-26 03:22:00 +03:00
Code

machined: add support for reporting image size via btrfs quota

Browse Source
This commit is contained in:
Lennart Poettering 2014-12-28 02:05:28 +01:00
parent 814f000872
commit b6b1849830
10 changed files with 413 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
src/machine/image-dbus.c
View File

@ -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),

74
src/machine/machinectl.c
View File

@ -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) },
{}
};

7
src/machine/machined-dbus.c
View File

@ -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),

23
src/shared/btrfs-ctree.h
View File

@ -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_;

180
src/shared/btrfs-util.c
View File

@ -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;
sh = (struct btrfs_ioctl_search_header*) args.buf;
assert(sh->type == BTRFS_ROOT_ITEM_KEY);
assert(sh->objectid == subvol_id);
args.key.nr_items = 256;
if (ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args) < 0)
return -errno;
if (sh->len < offsetof(struct btrfs_root_item, otime) + sizeof(struct btrfs_timespec))
return -ENOTSUP;
if (args.key.nr_items <= 0)
break;
ri = (struct btrfs_root_item *)(args.buf + sizeof(struct btrfs_ioctl_search_header));
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)) {
ret->otime = (usec_t) le64toh(ri->otime.sec) * USEC_PER_SEC +
(usec_t) le32toh(ri->otime.nsec) / NSEC_PER_USEC;
const struct btrfs_root_item *ri;
ret->subvol_id = subvol_id;
ret->read_only = !!(le64toh(ri->flags) & BTRFS_ROOT_SUBVOL_RDONLY);
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;
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));
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->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;
}
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;
}

8
src/shared/btrfs-util.h
View File

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

15
src/shared/machine-image.c
View File

@ -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;
}

5
src/shared/machine-image.h
View File

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

20
src/shared/missing.h
View File

@ -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

13
src/test/test-btrfs.c
View File

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