From: Eugene Syromyatnikov Date: Mon, 19 Mar 2018 04:49:05 +0000 (+0100) Subject: btrfs: use PRINT_FIELD_* X-Git-Tag: v4.23~290 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=f766447b180545a9533f8fc120f1f5a4c0f3a6fb;p=strace btrfs: use PRINT_FIELD_* * btrfs.c (btrfs_print_balance_args, btrfs_print_balance, btrfs_print_features, btrfs_print_qgroup_limit, btrfs_print_data_container_header, print_btrfs_data_container_logical_ino, btrfs_print_qgroup_inherit, btrfs_print_tree_search, print_btrfs_ioctl_space_info, btrfs_ioctl): Use PRINT_FIELD_* macros for printing structure fields. --- diff --git a/btrfs.c b/btrfs.c index 3db9d67b..4bfefc02 100644 --- a/btrfs.c +++ b/btrfs.c @@ -181,9 +181,9 @@ btrfs_unparse_uuid(unsigned char *uuid, char *out) static void btrfs_print_balance_args(const char *name, const struct btrfs_balance_args *bba) { - tprintf(", %s={profiles=", name); - printflags64(btrfs_space_info_flags, bba->profiles, - "BTRFS_BLOCK_GROUP_???"); + tprintf(", %s=", name); + PRINT_FIELD_FLAGS("{", *bba, profiles, btrfs_space_info_flags, + "BTRFS_BLOCK_GROUP_???"); PRINT_FIELD_U64(", ", *bba, usage); PRINT_FIELD_U64(", ", *bba, devid); PRINT_FIELD_U64(", ", *bba, pstart); @@ -191,8 +191,8 @@ btrfs_print_balance_args(const char *name, const struct btrfs_balance_args *bba) PRINT_FIELD_U64(", ", *bba, vstart); PRINT_FIELD_U64(", ", *bba, vend); PRINT_FIELD_U64(", ", *bba, target); - tprints(", flags="); - printflags64(btrfs_balance_args, bba->flags, "BTRFS_BALANCE_ARGS_???"); + PRINT_FIELD_FLAGS(", ", *bba, flags, btrfs_balance_args, + "BTRFS_BALANCE_ARGS_???"); tprints("}"); } @@ -204,14 +204,12 @@ btrfs_print_balance(struct tcb *const tcp, const kernel_ulong_t arg, bool out) if (umove_or_printaddr(tcp, arg, &balance_args)) return; - tprints("{flags="); - printflags64(btrfs_balance_flags, balance_args.flags, - "BTRFS_BALANCE_???"); - if (out) { - tprints(", state="); - printflags64(btrfs_balance_state, balance_args.state, - "BTRFS_BALANCE_STATE_???"); - } + PRINT_FIELD_FLAGS("{", balance_args, flags, btrfs_balance_flags, + "BTRFS_BALANCE_???"); + if (out) + PRINT_FIELD_FLAGS(", ", balance_args, state, + btrfs_balance_state, + "BTRFS_BALANCE_STATE_???"); if (balance_args.flags & BTRFS_BALANCE_DATA) btrfs_print_balance_args("data", &balance_args.data); @@ -225,30 +223,26 @@ btrfs_print_balance(struct tcb *const tcp, const kernel_ulong_t arg, bool out) static void btrfs_print_features(const struct btrfs_ioctl_feature_flags *flags) { - tprints("{compat_flags="); - printflags64(btrfs_features_compat, flags->compat_flags, - "BTRFS_FEATURE_COMPAT_???"); - - tprints(", compat_ro_flags="); - printflags64(btrfs_features_compat_ro, flags->compat_ro_flags, - "BTRFS_FEATURE_COMPAT_RO_???"); - - tprints(", incompat_flags="); - printflags64(btrfs_features_incompat, flags->incompat_flags, - "BTRFS_FEATURE_INCOMPAT_???"); + PRINT_FIELD_FLAGS("{", *flags, compat_flags, btrfs_features_compat, + "BTRFS_FEATURE_COMPAT_???"); + PRINT_FIELD_FLAGS(", ", *flags, compat_ro_flags, + btrfs_features_compat_ro, + "BTRFS_FEATURE_COMPAT_RO_???"); + PRINT_FIELD_FLAGS(", ", *flags, incompat_flags, btrfs_features_incompat, + "BTRFS_FEATURE_INCOMPAT_???"); tprints("}"); } static void btrfs_print_qgroup_limit(const struct btrfs_qgroup_limit *lim) { - tprints(", lim={flags="); - printflags64(btrfs_qgroup_limit_flags, lim->flags, - "BTRFS_QGROUP_LIMIT_???"); - tprintf(", max_rfer=%" PRI__u64 ", max_excl=%" PRI__u64 - ", rsv_rfer=%" PRI__u64 ", rsv_excl=%" PRI__u64 "}", - lim->max_rfer, lim->max_excl, - lim->rsv_rfer, lim->rsv_excl); + PRINT_FIELD_FLAGS(", lim={", *lim, flags, btrfs_qgroup_limit_flags, + "BTRFS_QGROUP_LIMIT_???"); + PRINT_FIELD_U(", ", *lim, max_rfer); + PRINT_FIELD_U(", ", *lim, max_excl); + PRINT_FIELD_U(", ", *lim, rsv_rfer); + PRINT_FIELD_U(", ", *lim, rsv_excl); + tprints("}"); } #define btrfs_print_key_type(prefix_, where_, field_) \ @@ -260,10 +254,10 @@ btrfs_print_qgroup_limit(const struct btrfs_qgroup_limit *lim) static void btrfs_print_data_container_header(const struct btrfs_data_container *container) { - tprintf("{bytes_left=%u, bytes_missing=%u" - ", elem_cnt=%u, elem_missed=%u", - container->bytes_left, container->bytes_missing, - container->elem_cnt, container->elem_missed); + PRINT_FIELD_U("{", *container, bytes_left); + PRINT_FIELD_U(", ", *container, bytes_missing); + PRINT_FIELD_U(", ", *container, elem_cnt); + PRINT_FIELD_U(", ", *container, elem_missed); } static void @@ -276,10 +270,16 @@ static bool print_btrfs_data_container_logical_ino(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data) { - const uint64_t *const record = elem_buf; + const struct { + uint64_t inum; + uint64_t offset; + uint64_t root; + } *const record = elem_buf; - tprintf("{inum=%" PRIu64 ", offset=%" PRIu64 ", root=%" PRIu64 "}", - record[0], record[1], record[2]); + PRINT_FIELD_U("{", *record, inum); + PRINT_FIELD_U(", ", *record, offset); + PRINT_FIELD_U(", ", *record, root); + tprints("}"); return true; } @@ -358,13 +358,11 @@ btrfs_print_qgroup_inherit(struct tcb *const tcp, const kernel_ulong_t qgi_addr) if (umove_or_printaddr(tcp, qgi_addr, &inherit)) return; - tprints("{flags="); - printflags64(btrfs_qgroup_inherit_flags, inherit.flags, - "BTRFS_QGROUP_INHERIT_???"); - tprintf(", num_qgroups=%" PRI__u64 ", num_ref_copies=%" PRI__u64 - ", num_excl_copies=%" PRI__u64, - inherit.num_qgroups, inherit.num_ref_copies, - inherit.num_excl_copies); + PRINT_FIELD_FLAGS("{", inherit, flags, btrfs_qgroup_inherit_flags, + "BTRFS_QGROUP_INHERIT_???"); + PRINT_FIELD_U(", ", inherit, num_qgroups); + PRINT_FIELD_U(", ", inherit, num_ref_copies); + PRINT_FIELD_U(", ", inherit, num_excl_copies); btrfs_print_qgroup_limit(&inherit.lim); @@ -402,12 +400,14 @@ btrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key, btrfs_print_key_type(", ", *key, min_type); btrfs_print_key_type(", ", *key, max_type); - tprintf(", nr_items=%u}", key->nr_items); + PRINT_FIELD_U(", ", *key, nr_items); + tprints("}"); if (print_size) tprintf(", buf_size=%" PRIu64, buf_size); tprints("}"); } else { - tprintf("{key={nr_items=%u}", key->nr_items); + PRINT_FIELD_U("{key={", *key, nr_items); + tprints("}"); if (print_size) tprintf(", buf_size=%" PRIu64, buf_size); if (abbrev(tcp)) { @@ -426,12 +426,12 @@ btrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key, tprints("..."); break; } - tprintf("{transid=%" PRI__u64, - sh.transid); + PRINT_FIELD_U("{", sh, transid); btrfs_print_objectid(", ", sh, objectid); - tprintf(", offset=%" PRI__u64, sh.offset); + PRINT_FIELD_U(", ", sh, offset); btrfs_print_key_type(", ", sh, type); - tprintf(", len=%u}", sh.len); + PRINT_FIELD_U(", ", sh, len); + tprints("}"); off += sizeof(sh) + sh.len; } @@ -457,11 +457,11 @@ print_btrfs_ioctl_space_info(struct tcb *tcp, void *elem_buf, { const struct btrfs_ioctl_space_info *info = elem_buf; - tprints("{flags="); - printflags64(btrfs_space_info_flags, info->flags, - "BTRFS_SPACE_INFO_???"); - tprintf(", total_bytes=%" PRI__u64 ", used_bytes=%" PRI__u64 "}", - info->total_bytes, info->used_bytes); + PRINT_FIELD_FLAGS("{", *info, flags, btrfs_space_info_flags, + "BTRFS_SPACE_INFO_???"); + PRINT_FIELD_U(", ", *info, total_bytes); + PRINT_FIELD_U(", ", *info, used_bytes); + tprints("}"); return true; } @@ -568,16 +568,14 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprintf("{start=%" PRIu64, (uint64_t)args.start); + PRINT_FIELD_U("{", args, start); PRINT_FIELD_U64(", ", args, len); - tprints(", flags="); - printflags64(btrfs_defrag_flags, args.flags, - "BTRFS_DEFRAG_RANGE_???"); - tprintf(", extent_thresh=%u, compress_type=", - args.extent_thresh); - printxval(btrfs_compress_types, args.compress_type, - "BTRFS_COMPRESS_???"); + PRINT_FIELD_FLAGS(", ", args, flags, btrfs_defrag_flags, + "BTRFS_DEFRAG_RANGE_???"); + PRINT_FIELD_U(", ", args, extent_thresh); + PRINT_FIELD_XVAL(", ", args, compress_type, + btrfs_compress_types, "BTRFS_COMPRESS_???"); tprints("}"); break; } @@ -598,19 +596,22 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, valid = btrfs_unparse_uuid(args.uuid, uuid); if (entering(tcp)) { - tprintf("{devid=%" PRI__u64, args.devid); + PRINT_FIELD_U("{", args, devid); if (valid) tprintf(", uuid=%s", uuid); tprints("}"); return 0; } + + tprints("{"); if (valid) tprintf("uuid=%s, ", uuid); - tprintf("bytes_used=%" PRI__u64 - ", total_bytes=%" PRI__u64, - args.bytes_used, args.total_bytes); + + PRINT_FIELD_U("", args, bytes_used); + PRINT_FIELD_U(", ", args, total_bytes); PRINT_FIELD_CSTRING(", ", args, path); tprints("}"); + break; } @@ -628,24 +629,17 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, break; if (entering(tcp)) { - tprints("{cmd="); - printxval64(btrfs_dev_replace_cmds, args.cmd, - "BTRFS_IOCTL_DEV_REPLACE_CMD_???"); + PRINT_FIELD_XVAL("{", args, cmd, btrfs_dev_replace_cmds, + "BTRFS_IOCTL_DEV_REPLACE_CMD_???"); if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_START) { - const char *str; - tprintf(", start={srcdevid=%" PRIu64 - ", cont_reading_from_srcdev_mode=%" PRIu64 - ", srcdev_name=", - (uint64_t) args.start.srcdevid, - (uint64_t) args.start.cont_reading_from_srcdev_mode); - - str = (const char *) args.start.srcdev_name; - print_quoted_cstring(str, - sizeof(args.start.srcdev_name)); - tprints(", tgtdev_name="); - str = (const char *) args.start.tgtdev_name; - print_quoted_cstring(str, - sizeof(args.start.tgtdev_name)); + PRINT_FIELD_U(", start={", args.start, + srcdevid); + PRINT_FIELD_U(", ", args.start, + cont_reading_from_srcdev_mode); + PRINT_FIELD_CSTRING(", ", args.start, + srcdev_name); + PRINT_FIELD_CSTRING(", ", args.start, + tgtdev_name); tprints("}"); } @@ -653,34 +647,28 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, return 0; } - tprints("{result="); - printxval64(btrfs_dev_replace_results, args.result, - "BTRFS_IOCTL_DEV_REPLACE_RESULT_???"); + PRINT_FIELD_XVAL("{", args, result, btrfs_dev_replace_results, + "BTRFS_IOCTL_DEV_REPLACE_RESULT_???"); if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS) { - tprints(", "); - printxval64(btrfs_dev_replace_state, - args.status.replace_state, - "BTRFS_IOCTL_DEV_REPLACE_STATE_???"); - tprintf(", progress_1000=%" PRIu64, - (uint64_t) args.status.progress_1000); + PRINT_FIELD_XVAL(", status={", args.status, + replace_state, btrfs_dev_replace_state, + "BTRFS_IOCTL_DEV_REPLACE_STATE_???"); + PRINT_FIELD_U(", ", args.status, progress_1000); if (args.status.progress_1000 <= 1000) tprintf_comment("%u.%u%%", (unsigned) args.status.progress_1000 / 10, (unsigned) args.status.progress_1000 % 10); - tprintf(", time_started=%" PRIu64, - (uint64_t) args.status.time_started); + PRINT_FIELD_U(", ", args.status, time_started); tprints_comment(sprinttime(args.status.time_started)); - tprintf(", time_stopped=%" PRIu64, - (uint64_t) args.status.time_stopped); + PRINT_FIELD_U(", ", args.status, time_stopped); tprints_comment(sprinttime(args.status.time_stopped)); - tprintf(", num_write_errors=%" PRIu64 - ", num_uncorrectable_read_errors=%" PRIu64, - (uint64_t) args.status.num_write_errors, - (uint64_t) args.status.num_uncorrectable_read_errors); + PRINT_FIELD_U(", ", args.status, num_write_errors); + PRINT_FIELD_U(", ", args.status, + num_uncorrectable_read_errors); } tprints("}"); break; @@ -769,12 +757,11 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, #endif btrfs_unparse_uuid(args.fsid, uuid); - tprints("{"); - tprintf("max_id=%" PRI__u64 ", num_devices=%" PRI__u64 - ", fsid=%s, nodesize=%u, sectorsize=%u" + PRINT_FIELD_U("{", args, max_id); + PRINT_FIELD_U(", ", args, num_devices); + tprintf(", fsid=%s, nodesize=%u, sectorsize=%u" ", clone_alignment=%u", - args.max_id, args.num_devices, uuid, - nodesize, sectorsize, clone_alignment); + uuid, nodesize, sectorsize, clone_alignment); tprints("}"); break; } @@ -794,12 +781,14 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, tprints("{"); - if (entering(tcp)) - tprintf("devid=%" PRI__u64 ", ", args.devid); + if (entering(tcp)) { + PRINT_FIELD_U("", args, devid); + tprints(", "); + } - tprintf("nr_items=%" PRI__u64 ", flags=", args.nr_items); - printflags64(btrfs_dev_stats_flags, args.flags, - "BTRFS_DEV_STATS_???"); + PRINT_FIELD_U("", args, nr_items); + PRINT_FIELD_FLAGS(", ", args, flags, btrfs_dev_stats_flags, + "BTRFS_DEV_STATS_???"); if (entering(tcp)) { tprints("}"); @@ -881,10 +870,9 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, break; if (entering(tcp)) { - tprintf("{inum=%" PRI__u64 ", size=%" PRI__u64, - args.inum, args.size); - tprints(", fspath="); - printaddr64(args.fspath); + PRINT_FIELD_U("{", args, inum); + PRINT_FIELD_U(", ", args, size); + PRINT_FIELD_ADDR64(", ", args, fspath); tprints("}"); return 0; } @@ -910,8 +898,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, break; if (entering(tcp)) { - tprintf("{logical=%" PRI__u64 ", size=%" PRI__u64, - args.logical, args.size); + PRINT_FIELD_U("{", args, logical); + PRINT_FIELD_U(", ", args, size); if (!IS_ARRAY_ZERO(args.reserved)) { tprints(", reserved=["); @@ -930,8 +918,7 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, args.reserved[3] #endif , "BTRFS_LOGICAL_INO_ARGS_???"); - tprints(", inodes="); - printaddr64(args.inodes); + PRINT_FIELD_ADDR64(", ", args, inodes); tprints("}"); return 0; } @@ -950,9 +937,10 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprintf("{assign=%" PRI__u64 ", src=%" PRI__u64 - ", dst=%" PRI__u64 "}", - args.assign, args.src, args.dst); + PRINT_FIELD_U("{", args, assign); + PRINT_FIELD_U(", ", args, src); + PRINT_FIELD_U(", ", args, dst); + tprints("}"); break; } @@ -963,8 +951,9 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprintf("{create=%" PRI__u64 ", qgroupid=%" PRI__u64 "}", - args.create, args.qgroupid); + PRINT_FIELD_U("{", args, create); + PRINT_FIELD_U(", ", args, qgroupid); + tprints("}"); break; } @@ -978,7 +967,7 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprintf("{qgroupid=%" PRI__u64, args.qgroupid); + PRINT_FIELD_U("{", args, qgroupid); btrfs_print_qgroup_limit(&args.lim); tprints("}"); break; @@ -991,9 +980,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprints("{cmd="); - printxval64(btrfs_qgroup_ctl_cmds, args.cmd, - "BTRFS_QUOTA_CTL_???"); + PRINT_FIELD_XVAL("{", args, cmd, btrfs_qgroup_ctl_cmds, + "BTRFS_QUOTA_CTL_???"); tprints("}"); break; @@ -1006,7 +994,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprintf("{flags=%" PRIu64 "}", (uint64_t) args.flags); + PRINT_FIELD_U("{", args, flags); + tprints("}"); break; } @@ -1020,7 +1009,7 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprintf("{flags=%" PRIu64, (uint64_t) args.flags); + PRINT_FIELD_U("{", args, flags); btrfs_print_objectid(", ", args, progress); tprints("}"); break; @@ -1042,15 +1031,15 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (entering(tcp)) { btrfs_unparse_uuid((unsigned char *)args.uuid, uuid); - tprintf("{uuid=%s, stransid=%" PRIu64, - uuid, (uint64_t) args.stransid); + tprintf("{uuid=%s", uuid); + PRINT_FIELD_U(", ", args, stransid); print_btrfs_timespec(", stime=", args.stime.sec, args.stime.nsec); - tprintf(", flags=%" PRIu64 "}", - (uint64_t) args.flags); + PRINT_FIELD_U(", ", args, flags); + tprints("}"); return 0; } - tprintf("{rtransid=%" PRIu64, (uint64_t) args.rtransid); + PRINT_FIELD_U("{", args, rtransid); print_btrfs_timespec(", rtime=", args.rtime.sec, args.rtime.nsec); tprints("}"); @@ -1072,48 +1061,34 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, break; if (entering(tcp)) { - tprintf("{devid=%" PRI__u64, args.devid); + PRINT_FIELD_U("{", args, devid); if (code == BTRFS_IOC_SCRUB) { - tprintf(", start=%" PRI__u64, - args.start); + PRINT_FIELD_U(", ", args, start); PRINT_FIELD_U64(", ", args, end); - tprints(", flags="); - printflags64(btrfs_scrub_flags, args.flags, - "BTRFS_SCRUB_???"); + PRINT_FIELD_FLAGS(", ", args, flags, + btrfs_scrub_flags, + "BTRFS_SCRUB_???"); } tprints("}"); return 0; } - tprintf("{data_extents_scrubbed=%" PRI__u64 - ", tree_extents_scrubbed=%" PRI__u64 - ", data_bytes_scrubbed=%" PRI__u64 - ", tree_bytes_scrubbed=%" PRI__u64 - ", read_errors=%" PRI__u64 - ", csum_errors=%" PRI__u64 - ", verify_errors=%" PRI__u64 - ", no_csum=%" PRI__u64 - ", csum_discards=%" PRI__u64 - ", super_errors=%" PRI__u64 - ", malloc_errors=%" PRI__u64 - ", uncorrectable_errors=%" PRI__u64 - ", corrected_errors=%" PRI__u64 - ", last_physical=%" PRI__u64 - ", unverified_errors=%" PRI__u64 "}", - args.progress.data_extents_scrubbed, - args.progress.tree_extents_scrubbed, - args.progress.data_bytes_scrubbed, - args.progress.tree_bytes_scrubbed, - args.progress.read_errors, - args.progress.csum_errors, - args.progress.verify_errors, - args.progress.no_csum, - args.progress.csum_discards, - args.progress.super_errors, - args.progress.malloc_errors, - args.progress.uncorrectable_errors, - args.progress.corrected_errors, - args.progress.last_physical, - args.progress.unverified_errors); + PRINT_FIELD_U("{progress={", args.progress, + data_extents_scrubbed); + PRINT_FIELD_U(", ", args.progress, tree_extents_scrubbed); + PRINT_FIELD_U(", ", args.progress, data_bytes_scrubbed); + PRINT_FIELD_U(", ", args.progress, tree_bytes_scrubbed); + PRINT_FIELD_U(", ", args.progress, read_errors); + PRINT_FIELD_U(", ", args.progress, csum_errors); + PRINT_FIELD_U(", ", args.progress, verify_errors); + PRINT_FIELD_U(", ", args.progress, no_csum); + PRINT_FIELD_U(", ", args.progress, csum_discards); + PRINT_FIELD_U(", ", args.progress, super_errors); + PRINT_FIELD_U(", ", args.progress, malloc_errors); + PRINT_FIELD_U(", ", args.progress, uncorrectable_errors); + PRINT_FIELD_U(", ", args.progress, corrected_errors); + PRINT_FIELD_U(", ", args.progress, last_physical); + PRINT_FIELD_U(", ", args.progress, unverified_errors); + tprints("}}"); break; } @@ -1150,8 +1125,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, tprints(" => "); if (!umove_or_printaddr_ignore_syserror(tcp, arg, &args)) - tprintf("{buf_size=%" PRIu64 "}", - (uint64_t)args.buf_size); + PRINT_FIELD_U("{", args, buf_size); + tprints("}"); } break; } else @@ -1175,10 +1150,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprints("{send_fd="); - printfd(tcp, args.send_fd); - tprintf(", clone_sources_count=%" PRIu64, - (uint64_t) args.clone_sources_count); + PRINT_FIELD_FD("{", args, send_fd, tcp); + PRINT_FIELD_U(", ", args, clone_sources_count); tprints(", clone_sources="); if (abbrev(tcp)) @@ -1192,9 +1165,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, print_objectid_callback, 0); } btrfs_print_objectid(", ", args, parent_root); - tprints(", flags="); - printflags64(btrfs_send_flags, args.flags, - "BTRFS_SEND_FLAGS_???"); + PRINT_FIELD_FLAGS(", ", args, flags, btrfs_send_flags, + "BTRFS_SEND_FLAGS_???"); tprints("}"); break; } @@ -1213,11 +1185,12 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, break; if (entering(tcp)) { - tprintf("{space_slots=%" PRI__u64 "}", args.space_slots); + PRINT_FIELD_U("{", args, space_slots); + tprints("}"); return 0; } - tprintf("{total_spaces=%" PRI__u64, args.total_spaces); + PRINT_FIELD_U("{", args, total_spaces); if (args.space_slots == 0 && args.total_spaces) { tprints("}"); @@ -1252,8 +1225,7 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, if (umove_or_printaddr(tcp, arg, &args)) break; - tprints("{fd="); - printfd(tcp, args.fd); + PRINT_FIELD_FD("{", args, fd, tcp); PRINT_FIELD_CSTRING(", ", args, name); tprints("}"); break; @@ -1274,15 +1246,13 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, break; if (entering(tcp)) { - tprints("{fd="); - printfd(tcp, args.fd); - tprints(", flags="); - printflags64(btrfs_snap_flags_v2, args.flags, - "BTRFS_SUBVOL_???"); + PRINT_FIELD_FD("{", args, fd, tcp); + PRINT_FIELD_FLAGS(", ", args, flags, + btrfs_snap_flags_v2, + "BTRFS_SUBVOL_???"); if (args.flags & BTRFS_SUBVOL_QGROUP_INHERIT) { - tprintf(", size=%" PRIu64 ", qgroup_inherit=", - (uint64_t) args.size); - + PRINT_FIELD_U(", ", args, size); + tprints(", qgroup_inherit="); btrfs_print_qgroup_inherit(tcp, ptr_to_kulong(args.qgroup_inherit)); } @@ -1290,7 +1260,8 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl, tprints("}"); return 0; } - tprintf("{transid=%" PRIu64 "}", (uint64_t) args.transid); + PRINT_FIELD_U("{", args, transid); + tprints("}"); break; }