RepoMirrors/btrfs-progs
1
0
Fork 0
mirror of https://github.com/kdave/btrfs-progs synced 2025-04-26 13:07:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "btrfs-progs: rename qgroup items to match the kernel naming scheme"

Browse Source 
This reverts commit 03451430de.
(It's not 1:1, there are some additional trivial fixups in cmds/qgroup.c)

This breaks a lot of 3rd party tools that depend on it as Neal reports:

* btrfs-assistant
* buildah
* cri-o
* podman
* skopeo
* containerd
* moby/docker
* snapper
* source-to-image

Link: https://lore.kernel.org/linux-btrfs/CAEg-Je8L7jieKdoWoZBuBZ6RdXwvwrx04AB0fOZF1fr5Pb-o1g@mail.gmail.com/
Reported-by: Neal Gompa <ngompa@fedoraproject.org>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
David Sterba 2023-01-03 12:41:23 +01:00
parent c339846763
commit e78fe2d92e
7 changed files with 130 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
check/qgroup-verify.c
View File

@ -49,10 +49,10 @@ struct qgroup_count;
static struct qgroup_count *find_count(u64 qgroupid); static struct qgroup_count *find_count(u64 qgroupid);
struct qgroup_info { struct qgroup_info {
u64 rfer; u64 referenced;
u64 rfer_cmpr; u64 referenced_compressed;
u64 excl; u64 exclusive;
u64 excl_cmpr; u64 exclusive_compressed;
}; };
struct qgroup_count { struct qgroup_count {
@ -481,12 +481,12 @@ static int account_one_extent(struct ulist *roots, u64 bytenr, u64 num_bytes)
nr_refs = group_get_cur_refcnt(count); nr_refs = group_get_cur_refcnt(count);
if (nr_refs) { if (nr_refs) {
count->info.rfer += num_bytes; count->info.referenced += num_bytes;
count->info.rfer_cmpr += num_bytes; count->info.referenced_compressed += num_bytes;
if (nr_refs == nr_roots) { if (nr_refs == nr_roots) {
count->info.excl += num_bytes; count->info.exclusive += num_bytes;
count->info.excl_cmpr += num_bytes; count->info.exclusive_compressed += num_bytes;
} }
} }
#ifdef QGROUP_VERIFY_DEBUG #ifdef QGROUP_VERIFY_DEBUG
@ -494,7 +494,7 @@ static int account_one_extent(struct ulist *roots, u64 bytenr, u64 num_bytes)
" excl %llu, refs %llu, roots %llu\n", bytenr, num_bytes, " excl %llu, refs %llu, roots %llu\n", bytenr, num_bytes,
btrfs_qgroup_level(count->qgroupid), btrfs_qgroup_level(count->qgroupid),
btrfs_qgroup_subvolid(count->qgroupid), btrfs_qgroup_subvolid(count->qgroupid),
count->info.rfer, count->info.excl, nr_refs, count->info.referenced, count->info.exclusive, nr_refs,
nr_roots); nr_roots);
#endif #endif
} }
@ -870,10 +870,12 @@ static struct qgroup_count *alloc_count(struct btrfs_disk_key *key,
c->key = *key; c->key = *key;
item = &c->diskinfo; item = &c->diskinfo;
item->rfer = btrfs_qgroup_info_rfer(leaf, disk); item->referenced = btrfs_qgroup_info_referenced(leaf, disk);
item->rfer_cmpr = btrfs_qgroup_info_rfer_cmpr(leaf, disk); item->referenced_compressed =
item->excl = btrfs_qgroup_info_excl(leaf, disk); btrfs_qgroup_info_referenced_compressed(leaf, disk);
item->excl_cmpr = btrfs_qgroup_info_excl_cmpr(leaf, disk); item->exclusive = btrfs_qgroup_info_exclusive(leaf, disk);
item->exclusive_compressed =
btrfs_qgroup_info_exclusive_compressed(leaf, disk);
INIT_LIST_HEAD(&c->groups); INIT_LIST_HEAD(&c->groups);
INIT_LIST_HEAD(&c->members); INIT_LIST_HEAD(&c->members);
INIT_LIST_HEAD(&c->bad_list); INIT_LIST_HEAD(&c->bad_list);
@ -1284,8 +1286,8 @@ static int report_qgroup_difference(struct qgroup_count *count, int verbose)
int is_different; int is_different;
struct qgroup_info *info = &count->info; struct qgroup_info *info = &count->info;
struct qgroup_info *disk = &count->diskinfo; struct qgroup_info *disk = &count->diskinfo;
long long excl_diff = info->excl - disk->excl; long long excl_diff = info->exclusive - disk->exclusive;
long long ref_diff = info->rfer - disk->rfer; long long ref_diff = info->referenced - disk->referenced;
is_different = excl_diff || ref_diff; is_different = excl_diff || ref_diff;
@ -1295,16 +1297,16 @@ static int report_qgroup_difference(struct qgroup_count *count, int verbose)
btrfs_qgroup_subvolid(count->qgroupid), btrfs_qgroup_subvolid(count->qgroupid),
is_different ? "are different" : ""); is_different ? "are different" : "");
print_fields(info->rfer, info->rfer_cmpr, print_fields(info->referenced, info->referenced_compressed,
"our:", "referenced"); "our:", "referenced");
print_fields(disk->rfer, disk->rfer_cmpr, print_fields(disk->referenced, disk->referenced_compressed,
"disk:", "referenced"); "disk:", "referenced");
if (ref_diff) if (ref_diff)
print_fields_signed(ref_diff, ref_diff, print_fields_signed(ref_diff, ref_diff,
"diff:", "referenced"); "diff:", "referenced");
print_fields(info->excl, info->excl_cmpr, print_fields(info->exclusive, info->exclusive_compressed,
"our:", "exclusive"); "our:", "exclusive");
print_fields(disk->excl, disk->excl_cmpr, print_fields(disk->exclusive, disk->exclusive_compressed,
"disk:", "exclusive"); "disk:", "exclusive");
if (excl_diff) if (excl_diff)
print_fields_signed(excl_diff, excl_diff, print_fields_signed(excl_diff, excl_diff,
@ -1386,8 +1388,8 @@ static bool is_bad_qgroup(struct qgroup_count *count)
{ {
struct qgroup_info *info = &count->info; struct qgroup_info *info = &count->info;
struct qgroup_info *disk = &count->diskinfo; struct qgroup_info *disk = &count->diskinfo;
s64 excl_diff = info->excl - disk->excl; s64 excl_diff = info->exclusive - disk->exclusive;
s64 ref_diff = info->rfer - disk->rfer; s64 ref_diff = info->referenced - disk->referenced;
return (excl_diff || ref_diff); return (excl_diff || ref_diff);
} }
@ -1592,15 +1594,15 @@ static int repair_qgroup_info(struct btrfs_fs_info *info,
btrfs_set_qgroup_info_generation(path.nodes[0], info_item, btrfs_set_qgroup_info_generation(path.nodes[0], info_item,
trans->transid); trans->transid);
btrfs_set_qgroup_info_rfer(path.nodes[0], info_item, btrfs_set_qgroup_info_referenced(path.nodes[0], info_item,
count->info.rfer); count->info.referenced);
btrfs_set_qgroup_info_rfer_cmpr(path.nodes[0], info_item, btrfs_set_qgroup_info_referenced_compressed(path.nodes[0], info_item,
count->info.rfer_cmpr); count->info.referenced_compressed);
btrfs_set_qgroup_info_excl(path.nodes[0], info_item, btrfs_set_qgroup_info_exclusive(path.nodes[0], info_item,
count->info.excl); count->info.exclusive);
btrfs_set_qgroup_info_excl_cmpr(path.nodes[0], info_item, btrfs_set_qgroup_info_exclusive_compressed(path.nodes[0], info_item,
count->info.excl_cmpr); count->info.exclusive_compressed);
btrfs_mark_buffer_dirty(path.nodes[0]); btrfs_mark_buffer_dirty(path.nodes[0]);

65
cmds/qgroup.c
View File

@ -343,10 +343,10 @@ static void print_qgroup_column(struct btrfs_qgroup *qgroup,
print_qgroup_column_add_blank(BTRFS_QGROUP_QGROUPID, len); print_qgroup_column_add_blank(BTRFS_QGROUP_QGROUPID, len);
break; break;
case BTRFS_QGROUP_RFER: case BTRFS_QGROUP_RFER:
len = print_u64(qgroup->info.rfer, unit_mode, max_len); len = print_u64(qgroup->info.referenced, unit_mode, max_len);
break; break;
case BTRFS_QGROUP_EXCL: case BTRFS_QGROUP_EXCL:
len = print_u64(qgroup->info.excl, unit_mode, max_len); len = print_u64(qgroup->info.exclusive, unit_mode, max_len);
break; break;
case BTRFS_QGROUP_PARENT: case BTRFS_QGROUP_PARENT:
len = print_parent_column(qgroup); len = print_parent_column(qgroup);
@ -354,14 +354,14 @@ static void print_qgroup_column(struct btrfs_qgroup *qgroup,
break; break;
case BTRFS_QGROUP_MAX_RFER: case BTRFS_QGROUP_MAX_RFER:
if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_RFER) if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_RFER)
len = print_u64(qgroup->limit.max_rfer, len = print_u64(qgroup->limit.max_referenced,
unit_mode, max_len); unit_mode, max_len);
else else
len = printf("%*s", max_len, "none"); len = printf("%*s", max_len, "none");
break; break;
case BTRFS_QGROUP_MAX_EXCL: case BTRFS_QGROUP_MAX_EXCL:
if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_EXCL)
len = print_u64(qgroup->limit.max_excl, len = print_u64(qgroup->limit.max_exclusive,
unit_mode, max_len); unit_mode, max_len);
else else
len = printf("%*s", max_len, "none"); len = printf("%*s", max_len, "none");
@ -504,9 +504,9 @@ static int comp_entry_with_rfer(struct btrfs_qgroup *entry1,
{ {
int ret; int ret;
if (entry1->info.rfer > entry2->info.rfer) if (entry1->info.referenced > entry2->info.referenced)
ret = 1; ret = 1;
else if (entry1->info.rfer < entry2->info.rfer) else if (entry1->info.referenced < entry2->info.referenced)
ret = -1; ret = -1;
else else
ret = 0; ret = 0;
@ -520,9 +520,9 @@ static int comp_entry_with_excl(struct btrfs_qgroup *entry1,
{ {
int ret; int ret;
if (entry1->info.excl > entry2->info.excl) if (entry1->info.exclusive > entry2->info.exclusive)
ret = 1; ret = 1;
else if (entry1->info.excl < entry2->info.excl) else if (entry1->info.exclusive < entry2->info.exclusive)
ret = -1; ret = -1;
else else
ret = 0; ret = 0;
@ -536,9 +536,9 @@ static int comp_entry_with_max_rfer(struct btrfs_qgroup *entry1,
{ {
int ret; int ret;
if (entry1->limit.max_rfer > entry2->limit.max_rfer) if (entry1->limit.max_referenced > entry2->limit.max_referenced)
ret = 1; ret = 1;
else if (entry1->limit.max_rfer < entry2->limit.max_rfer) else if (entry1->limit.max_referenced < entry2->limit.max_referenced)
ret = -1; ret = -1;
else else
ret = 0; ret = 0;
@ -552,9 +552,9 @@ static int comp_entry_with_max_excl(struct btrfs_qgroup *entry1,
{ {
int ret; int ret;
if (entry1->limit.max_excl > entry2->limit.max_excl) if (entry1->limit.max_exclusive > entry2->limit.max_exclusive)
ret = 1; ret = 1;
else if (entry1->limit.max_excl < entry2->limit.max_excl) else if (entry1->limit.max_exclusive < entry2->limit.max_exclusive)
ret = -1; ret = -1;
else else
ret = 0; ret = 0;
@ -807,10 +807,12 @@ static int update_qgroup_info(int fd, struct qgroup_lookup *qgroup_lookup, u64 q
return PTR_ERR(bq); return PTR_ERR(bq);
bq->info.generation = btrfs_stack_qgroup_info_generation(info); bq->info.generation = btrfs_stack_qgroup_info_generation(info);
bq->info.rfer = btrfs_stack_qgroup_info_rfer(info); bq->info.referenced = btrfs_stack_qgroup_info_referenced(info);
bq->info.rfer_cmpr = btrfs_stack_qgroup_info_rfer_cmpr(info); bq->info.referenced_compressed =
bq->info.excl = btrfs_stack_qgroup_info_excl(info); btrfs_stack_qgroup_info_referenced_compressed(info);
bq->info.excl_cmpr = btrfs_stack_qgroup_info_excl_cmpr(info); bq->info.exclusive = btrfs_stack_qgroup_info_exclusive(info);
bq->info.exclusive_compressed =
btrfs_stack_qgroup_info_exclusive_compressed(info);
return 0; return 0;
} }
@ -826,10 +828,13 @@ static int update_qgroup_limit(int fd, struct qgroup_lookup *qgroup_lookup,
return PTR_ERR(bq); return PTR_ERR(bq);
bq->limit.flags = btrfs_stack_qgroup_limit_flags(limit); bq->limit.flags = btrfs_stack_qgroup_limit_flags(limit);
bq->limit.max_rfer = btrfs_stack_qgroup_limit_max_rfer(limit); bq->limit.max_referenced =
bq->limit.max_excl = btrfs_stack_qgroup_limit_max_excl(limit); btrfs_stack_qgroup_limit_max_referenced(limit);
bq->limit.rsv_rfer = btrfs_stack_qgroup_limit_rsv_rfer(limit); bq->limit.max_exclusive =
bq->limit.rsv_excl = btrfs_stack_qgroup_limit_rsv_excl(limit); btrfs_stack_qgroup_limit_max_exclusive(limit);
bq->limit.rsv_referenced =
btrfs_stack_qgroup_limit_rsv_referenced(limit);
bq->limit.rsv_exclusive = btrfs_stack_qgroup_limit_rsv_exclusive(limit);
return 0; return 0;
} }
@ -1122,23 +1127,23 @@ static void __update_columns_max_len(struct btrfs_qgroup *bq,
btrfs_qgroup_columns[column].max_len = len; btrfs_qgroup_columns[column].max_len = len;
break; break;
case BTRFS_QGROUP_RFER: case BTRFS_QGROUP_RFER:
len = strlen(pretty_size_mode(bq->info.rfer, unit_mode)); len = strlen(pretty_size_mode(bq->info.referenced, unit_mode));
if (btrfs_qgroup_columns[column].max_len < len) if (btrfs_qgroup_columns[column].max_len < len)
btrfs_qgroup_columns[column].max_len = len; btrfs_qgroup_columns[column].max_len = len;
break; break;
case BTRFS_QGROUP_EXCL: case BTRFS_QGROUP_EXCL:
len = strlen(pretty_size_mode(bq->info.excl, unit_mode)); len = strlen(pretty_size_mode(bq->info.exclusive, unit_mode));
if (btrfs_qgroup_columns[column].max_len < len) if (btrfs_qgroup_columns[column].max_len < len)
btrfs_qgroup_columns[column].max_len = len; btrfs_qgroup_columns[column].max_len = len;
break; break;
case BTRFS_QGROUP_MAX_RFER: case BTRFS_QGROUP_MAX_RFER:
len = strlen(pretty_size_mode(bq->limit.max_rfer, len = strlen(pretty_size_mode(bq->limit.max_referenced,
unit_mode)); unit_mode));
if (btrfs_qgroup_columns[column].max_len < len) if (btrfs_qgroup_columns[column].max_len < len)
btrfs_qgroup_columns[column].max_len = len; btrfs_qgroup_columns[column].max_len = len;
break; break;
case BTRFS_QGROUP_MAX_EXCL: case BTRFS_QGROUP_MAX_EXCL:
len = strlen(pretty_size_mode(bq->limit.max_excl, len = strlen(pretty_size_mode(bq->limit.max_exclusive,
unit_mode)); unit_mode));
if (btrfs_qgroup_columns[column].max_len < len) if (btrfs_qgroup_columns[column].max_len < len)
btrfs_qgroup_columns[column].max_len = len; btrfs_qgroup_columns[column].max_len = len;
@ -1472,14 +1477,14 @@ static void print_all_qgroups_json(struct qgroup_lookup *qgroup_lookup)
fmt_print(&fctx, "qgroupid", fmt_print(&fctx, "qgroupid",
btrfs_qgroup_level(qgroup->qgroupid), btrfs_qgroup_level(qgroup->qgroupid),
btrfs_qgroup_subvolid(qgroup->qgroupid)); btrfs_qgroup_subvolid(qgroup->qgroupid));
fmt_print(&fctx, "referenced", qgroup->info.rfer); fmt_print(&fctx, "referenced", qgroup->info.referenced);
if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_RFER) if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_RFER)
fmt_print(&fctx, "max_referenced", qgroup->limit.max_rfer); fmt_print(&fctx, "max_referenced", qgroup->limit.max_referenced);
else else
fmt_print(&fctx, "max_referenced-none", "none"); fmt_print(&fctx, "max_referenced-none", "none");
fmt_print(&fctx, "exclusive", qgroup->info.excl); fmt_print(&fctx, "exclusive", qgroup->info.exclusive);
if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) if (qgroup->limit.flags & BTRFS_QGROUP_LIMIT_MAX_EXCL)
fmt_print(&fctx, "max_exclusive", qgroup->limit.max_excl); fmt_print(&fctx, "max_exclusive", qgroup->limit.max_exclusive);
else else
fmt_print(&fctx, "max_exclusive-none", "none"); fmt_print(&fctx, "max_exclusive-none", "none");
fmt_print(&fctx, "path", qgroup->path ?: ""); fmt_print(&fctx, "path", qgroup->path ?: "");
@ -2109,10 +2114,10 @@ static int cmd_qgroup_limit(const struct cmd_struct *cmd, int argc, char **argv)
BTRFS_QGROUP_LIMIT_EXCL_CMPR; BTRFS_QGROUP_LIMIT_EXCL_CMPR;
if (exclusive) { if (exclusive) {
args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_EXCL; args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_EXCL;
args.lim.max_excl = size; args.lim.max_exclusive = size;
} else { } else {
args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_RFER; args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_RFER;
args.lim.max_rfer = size; args.lim.max_referenced = size;
} }
if (argc - optind == 2) { if (argc - optind == 2) {

8
cmds/qgroup.h
View File

@ -24,10 +24,10 @@
struct btrfs_qgroup_info { struct btrfs_qgroup_info {
u64 generation; u64 generation;
u64 rfer; u64 referenced;
u64 rfer_cmpr; u64 referenced_compressed;
u64 excl; u64 exclusive;
u64 excl_cmpr; u64 exclusive_compressed;
}; };
struct btrfs_qgroup_stats { struct btrfs_qgroup_stats {

12
cmds/subvolume.c
View File

@ -1483,15 +1483,15 @@ static int cmd_subvolume_show(const struct cmd_struct *cmd, int argc, char **arg
fflush(stdout); fflush(stdout);
pr_verbose(LOG_DEFAULT, "\t Limit referenced:\t%s\n", pr_verbose(LOG_DEFAULT, "\t Limit referenced:\t%s\n",
stats.limit.max_rfer == 0 ? "-" : stats.limit.max_referenced == 0 ? "-" :
pretty_size_mode(stats.limit.max_rfer, unit_mode)); pretty_size_mode(stats.limit.max_referenced, unit_mode));
pr_verbose(LOG_DEFAULT, "\t Limit exclusive:\t%s\n", pr_verbose(LOG_DEFAULT, "\t Limit exclusive:\t%s\n",
stats.limit.max_excl == 0 ? "-" : stats.limit.max_exclusive == 0 ? "-" :
pretty_size_mode(stats.limit.max_excl, unit_mode)); pretty_size_mode(stats.limit.max_exclusive, unit_mode));
pr_verbose(LOG_DEFAULT, "\t Usage referenced:\t%s\n", pr_verbose(LOG_DEFAULT, "\t Usage referenced:\t%s\n",
pretty_size_mode(stats.info.rfer, unit_mode)); pretty_size_mode(stats.info.referenced, unit_mode));
pr_verbose(LOG_DEFAULT, "\t Usage exclusive:\t%s\n", pr_verbose(LOG_DEFAULT, "\t Usage exclusive:\t%s\n",
pretty_size_mode(stats.info.excl, unit_mode)); pretty_size_mode(stats.info.exclusive, unit_mode));
out: out:
free(subvol_path); free(subvol_path);

8
ioctl.h
View File

@ -71,10 +71,10 @@ BUILD_ASSERT(sizeof(struct btrfs_ioctl_vol_args) == 4096);
struct btrfs_qgroup_limit { struct btrfs_qgroup_limit {
__u64 flags; __u64 flags;
__u64 max_rfer; __u64 max_referenced;
__u64 max_excl; __u64 max_exclusive;
__u64 rsv_rfer; __u64 rsv_referenced;
__u64 rsv_excl; __u64 rsv_exclusive;
}; };
BUILD_ASSERT(sizeof(struct btrfs_qgroup_limit) == 40); BUILD_ASSERT(sizeof(struct btrfs_qgroup_limit) == 40);

79
kernel-shared/ctree.h
View File

@ -1099,10 +1099,10 @@ struct btrfs_free_space_info {
struct btrfs_qgroup_info_item { struct btrfs_qgroup_info_item {
__le64 generation; __le64 generation;
__le64 rfer; __le64 referenced;
__le64 rfer_cmpr; __le64 referenced_compressed;
__le64 excl; __le64 exclusive;
__le64 excl_cmpr; __le64 exclusive_compressed;
} __attribute__ ((__packed__)); } __attribute__ ((__packed__));
/* flags definition for qgroup limits */ /* flags definition for qgroup limits */
@ -1115,10 +1115,10 @@ struct btrfs_qgroup_info_item {
struct btrfs_qgroup_limit_item { struct btrfs_qgroup_limit_item {
__le64 flags; __le64 flags;
__le64 max_rfer; __le64 max_referenced;
__le64 max_excl; __le64 max_exclusive;
__le64 rsv_rfer; __le64 rsv_referenced;
__le64 rsv_excl; __le64 rsv_exclusive;
} __attribute__ ((__packed__)); } __attribute__ ((__packed__));
struct btrfs_space_info { struct btrfs_space_info {
@ -2450,47 +2450,48 @@ BTRFS_SETGET_STACK_FUNCS(stack_qgroup_status_rescan,
/* btrfs_qgroup_info_item */ /* btrfs_qgroup_info_item */
BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item, BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
generation, 64); generation, 64);
BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, BTRFS_SETGET_FUNCS(qgroup_info_referenced, struct btrfs_qgroup_info_item,
rfer, 64); referenced, 64);
BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, BTRFS_SETGET_FUNCS(qgroup_info_referenced_compressed,
struct btrfs_qgroup_info_item, rfer_cmpr, 64); struct btrfs_qgroup_info_item, referenced_compressed, 64);
BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64); BTRFS_SETGET_FUNCS(qgroup_info_exclusive, struct btrfs_qgroup_info_item,
BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, exclusive, 64);
struct btrfs_qgroup_info_item, excl_cmpr, 64); BTRFS_SETGET_FUNCS(qgroup_info_exclusive_compressed,
struct btrfs_qgroup_info_item, exclusive_compressed, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
struct btrfs_qgroup_info_item, generation, 64); struct btrfs_qgroup_info_item, generation, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_referenced,
struct btrfs_qgroup_info_item, rfer, 64); struct btrfs_qgroup_info_item, referenced, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_referenced_compressed,
struct btrfs_qgroup_info_item, rfer_cmpr, 64); struct btrfs_qgroup_info_item, referenced_compressed, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_exclusive,
struct btrfs_qgroup_info_item, excl, 64); struct btrfs_qgroup_info_item, exclusive, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_exclusive_compressed,
struct btrfs_qgroup_info_item, excl_cmpr, 64); struct btrfs_qgroup_info_item, exclusive_compressed, 64);
/* btrfs_qgroup_limit_item */ /* btrfs_qgroup_limit_item */
BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item, BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
flags, 64); flags, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item, BTRFS_SETGET_FUNCS(qgroup_limit_max_referenced, struct btrfs_qgroup_limit_item,
max_rfer, 64); max_referenced, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item, BTRFS_SETGET_FUNCS(qgroup_limit_max_exclusive, struct btrfs_qgroup_limit_item,
max_excl, 64); max_exclusive, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item, BTRFS_SETGET_FUNCS(qgroup_limit_rsv_referenced, struct btrfs_qgroup_limit_item,
rsv_rfer, 64); rsv_referenced, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item, BTRFS_SETGET_FUNCS(qgroup_limit_rsv_exclusive, struct btrfs_qgroup_limit_item,
rsv_excl, 64); rsv_exclusive, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_flags, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_flags,
struct btrfs_qgroup_limit_item, flags, 64); struct btrfs_qgroup_limit_item, flags, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_max_rfer, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_max_referenced,
struct btrfs_qgroup_limit_item, max_rfer, 64); struct btrfs_qgroup_limit_item, max_referenced, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_max_excl, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_max_exclusive,
struct btrfs_qgroup_limit_item, max_excl, 64); struct btrfs_qgroup_limit_item, max_exclusive, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_rsv_rfer, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_rsv_referenced,
struct btrfs_qgroup_limit_item, rsv_rfer, 64); struct btrfs_qgroup_limit_item, rsv_referenced, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_rsv_excl, BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_rsv_exclusive,
struct btrfs_qgroup_limit_item, rsv_excl, 64); struct btrfs_qgroup_limit_item, rsv_exclusive, 64);
/* btrfs_balance_item */ /* btrfs_balance_item */
BTRFS_SETGET_FUNCS(balance_item_flags, struct btrfs_balance_item, flags, 64); BTRFS_SETGET_FUNCS(balance_item_flags, struct btrfs_balance_item, flags, 64);

18
kernel-shared/print-tree.c
View File

@ -1089,10 +1089,12 @@ static void print_qgroup_info(struct extent_buffer *eb, int slot)
"\t\treferenced %llu referenced_compressed %llu\n" "\t\treferenced %llu referenced_compressed %llu\n"
"\t\texclusive %llu exclusive_compressed %llu\n", "\t\texclusive %llu exclusive_compressed %llu\n",
(unsigned long long)btrfs_qgroup_info_generation(eb, qg_info), (unsigned long long)btrfs_qgroup_info_generation(eb, qg_info),
(unsigned long long)btrfs_qgroup_info_rfer(eb, qg_info), (unsigned long long)btrfs_qgroup_info_referenced(eb, qg_info),
(unsigned long long)btrfs_qgroup_info_rfer_cmpr(eb, qg_info), (unsigned long long)btrfs_qgroup_info_referenced_compressed(eb,
(unsigned long long)btrfs_qgroup_info_excl(eb, qg_info), qg_info),
(unsigned long long)btrfs_qgroup_info_excl_cmpr(eb, qg_info)); (unsigned long long)btrfs_qgroup_info_exclusive(eb, qg_info),
(unsigned long long)btrfs_qgroup_info_exclusive_compressed(eb,
qg_info));
} }
static void print_qgroup_limit(struct extent_buffer *eb, int slot) static void print_qgroup_limit(struct extent_buffer *eb, int slot)
@ -1104,10 +1106,10 @@ static void print_qgroup_limit(struct extent_buffer *eb, int slot)
"\t\tmax_referenced %lld max_exclusive %lld\n" "\t\tmax_referenced %lld max_exclusive %lld\n"
"\t\trsv_referenced %lld rsv_exclusive %lld\n", "\t\trsv_referenced %lld rsv_exclusive %lld\n",
(unsigned long long)btrfs_qgroup_limit_flags(eb, qg_limit), (unsigned long long)btrfs_qgroup_limit_flags(eb, qg_limit),
(long long)btrfs_qgroup_limit_max_rfer(eb, qg_limit), (long long)btrfs_qgroup_limit_max_referenced(eb, qg_limit),
(long long)btrfs_qgroup_limit_max_excl(eb, qg_limit), (long long)btrfs_qgroup_limit_max_exclusive(eb, qg_limit),
(long long)btrfs_qgroup_limit_rsv_rfer(eb, qg_limit), (long long)btrfs_qgroup_limit_rsv_referenced(eb, qg_limit),
(long long)btrfs_qgroup_limit_rsv_excl(eb, qg_limit)); (long long)btrfs_qgroup_limit_rsv_exclusive(eb, qg_limit));
} }
static void print_persistent_item(struct extent_buffer *eb, void *ptr, static void print_persistent_item(struct extent_buffer *eb, void *ptr,