* defs.h (tprintf_comment, tprints_comment): New prototypes.
* strace.c (tvprintf): New function.
(tprintf): Use it.
(tprintf_comment, tprints_comment): New functions.
* aio.c (tprint_lio_opcode): Use tprints_comment.
* dm.c (dm_decode_dm_target_spec, dm_decode_dm_target_deps,
dm_decode_dm_name_list, dm_decode_dm_target_versions,
dm_decode_dm_target_msg, dm_decode_string, dm_known_ioctl): Likewise.
* futex.c (SYS_FUNC(futex)): Likewise.
* perf.c (print_perf_event_attr): Likewise.
* seccomp.c (decode_bpf_code): Likewise.
* util.c (printxvals, printxval_searchn, printflags64): Likewise.
* btrfs.c (print_u64, btrfs_print_key_type, btrfs_print_objectid,
print_key_value_internal): Likewise.
(btrfs_ioctl): Use tprints_comment and tprintf_comment.
* dirent.c (SYS_FUNC(getdents)): Likewise.
* dirent64.c (SYS_FUNC(getdents64)): Likewise.
* execve.c (printargc): Use tprintf_comment.
* tests/btrfs.c (btrfs_test_get_dev_stats_ioctl,
btrfs_test_features_ioctls): Update expected output.
tprints(cmds[cmd].name);
return cmds[cmd].sub;
}
- tprintf("%u /* SUB_??? */", cmd);
+ tprintf("%u", cmd);
+ tprints_comment("SUB_???");
return SUB_NONE;
}
{
tprintf(", %s=%" PRIu64, name, value);
if (value == UINT64_MAX)
- tprints(" /* UINT64_MAX */");
+ tprints_comment("UINT64_MAX");
}
#define print_member_u64(obj, name) print_u64(#name, obj->name)
static void
btrfs_print_key_type(uint32_t type)
{
- const char *str = xlookup(btrfs_key_types, type);
tprintf("%u", type);
- if (str)
- tprintf(" /* %s */", str);
+ tprints_comment(xlookup(btrfs_key_types, type));
}
static void
btrfs_print_objectid(uint64_t objectid)
{
- const char *str = xlookup(btrfs_tree_objectids, objectid);
tprintf("%" PRIu64, objectid);
- if (str)
- tprintf(" /* %s */", str);
+ tprints_comment(xlookup(btrfs_tree_objectids, objectid));
}
static void
if (value) {
tprintf(", %s=%" PRIu64, name, value);
if (value == UINT64_MAX)
- tprints(" /* UINT64_MAX */");
+ tprints_comment("UINT64_MAX");
}
}
#define print_key_value(tcp, key, name) \
tprintf("%" PRIu64, (uint64_t) args.len);
if (args.len == UINT64_MAX)
- tprints(" /* UINT64_MAX */");
+ tprints_comment("UINT64_MAX");
tprints(", flags=");
printflags64(btrfs_defrag_flags, args.flags,
printxval64(btrfs_dev_replace_results, args.result,
"BTRFS_IOCTL_DEV_REPLACE_RESULT_???");
if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS) {
- char buf[sizeof("HH:MM:SS") + 1];
- time_t time;
tprints(", ");
printxval64(btrfs_dev_replace_state,
args.status.replace_state,
"BTRFS_IOCTL_DEV_REPLACE_STATE_???");
- tprintf(", progress_1000=%" PRIu64 " /* ",
+ tprintf(", progress_1000=%" PRIu64,
(uint64_t) args.status.progress_1000);
+
if (args.status.progress_1000 <= 1000)
- tprintf("%" PRIu64 ".%.2" PRIu64 "%%",
- (uint64_t) args.status.progress_1000 / 10,
- (uint64_t) args.status.progress_1000 % 10);
- else
- tprints("???");
- tprints(" */ ,");
-
- time = args.status.time_started;
- strftime(buf, sizeof(buf), "%T",
- localtime(&time));
- tprintf("time_started=%" PRIu64" /* %s */, ",
- (uint64_t) args.status.time_started, buf);
-
- time = args.status.time_stopped;
- strftime(buf, sizeof(buf), "%T",
- localtime(&time));
- tprintf("time_stopped=%" PRIu64" /* %s */, ",
- (uint64_t) args.status.time_stopped, buf);
-
- tprintf("num_write_errors=%" PRIu64
+ 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);
+ tprints_comment(sprinttime(args.status.time_started));
+
+ tprintf(", time_stopped=%" PRIu64,
+ (uint64_t) 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);
if (umove_or_printaddr(tcp, arg, &flarg))
break;
- tprints("[ /* supported */ ");
+ tprints("[");
btrfs_print_features(&flarg[0]);
+ tprints_comment("supported");
- tprints(", /* safe to set */ ");
+ tprints(", ");
btrfs_print_features(&flarg[1]);
+ tprints_comment("safe to set");
- tprints(", /* safe to clear */ ");
+ tprints(", ");
btrfs_print_features(&flarg[2]);
+ tprints_comment("safe to clear");
tprints("]");
break;
tprints("...");
break;
}
- const char *name = xlookup(btrfs_dev_stats_values, i);
- if (name)
- tprintf("/* %s */ ", name);
tprintf("%" PRI__u64, args.values[i]);
+ tprints_comment(xlookup(btrfs_dev_stats_values, i));
}
tprints("]}");
break;
args.start);
tprintf("%" PRI__u64, args.end);
if (args.end == UINT64_MAX)
- tprints(" /* UINT64_MAX */");
+ tprints_comment("UINT64_MAX");
tprints(", flags=");
printflags64(btrfs_scrub_flags, args.flags,
"BTRFS_SCRUB_???");
extern void tabto(void);
extern void tprintf(const char *fmt, ...) ATTRIBUTE_FORMAT((printf, 1, 2));
extern void tprints(const char *str);
+extern void tprintf_comment(const char *fmt, ...) ATTRIBUTE_FORMAT((printf, 1, 2));
+extern void tprints_comment(const char *str);
#if SUPPORTED_PERSONALITIES > 1
extern void set_personality(int personality);
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprints(", ");
return 0;
}
const unsigned int count = tcp->u_arg[2];
if (syserror(tcp) || !verbose(tcp)) {
+ tprints(", ");
printaddr(tcp->u_arg[1]);
tprintf(", %u", count);
return 0;
if (len) {
buf = malloc(len);
if (!buf || umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
+ tprints(", ");
printaddr(tcp->u_arg[1]);
tprintf(", %u", count);
free(buf);
buf = NULL;
}
+ tprints(",");
if (!abbrev(tcp))
- tprints("[");
+ tprints(" [");
for (i = 0; len && i <= len - sizeof(kernel_dirent); ) {
kernel_dirent *d = (kernel_dirent *) &buf[i];
}
dents++;
if (d->d_reclen < sizeof(kernel_dirent)) {
- tprints("/* d_reclen < sizeof(struct dirent) */");
+ tprints_comment("d_reclen < sizeof(struct dirent)");
break;
}
i += d->d_reclen;
if (!abbrev(tcp))
tprints("]");
else
- tprintf("/* %u entries */", dents);
+ tprintf_comment("%u entries", dents);
tprintf(", %u", count);
free(buf);
return 0;
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprints(", ");
return 0;
}
const unsigned int count = tcp->u_arg[2];
if (syserror(tcp) || !verbose(tcp)) {
+ tprints(", ");
printaddr(tcp->u_arg[1]);
tprintf(", %u", count);
return 0;
if (len) {
buf = malloc(len);
if (!buf || umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
+ tprints(", ");
printaddr(tcp->u_arg[1]);
tprintf(", %u", count);
free(buf);
buf = NULL;
}
+ tprints(",");
if (!abbrev(tcp))
- tprints("[");
+ tprints(" [");
for (i = 0; len && i <= len - d_name_offset; ) {
struct dirent64 *d = (struct dirent64 *) &buf[i];
if (!abbrev(tcp)) {
tprints("}");
}
if (d->d_reclen < d_name_offset) {
- tprints("/* d_reclen < offsetof(struct dirent64, d_name) */");
+ tprints_comment("d_reclen < offsetof(struct dirent64, d_name)");
break;
}
i += d->d_reclen;
if (!abbrev(tcp))
tprints("]");
else
- tprintf("/* %u entries */", dents);
+ tprintf_comment("%u entries", dents);
tprintf(", %u", count);
free(buf);
return 0;
misplaced:
tprints("???");
- tprints(" /* misplaced struct dm_target_spec */");
+ tprints_comment("misplaced struct dm_target_spec");
}
bool
misplaced:
tprints("???");
- tprints(" /* misplaced struct dm_target_deps */");
+ tprints_comment("misplaced struct dm_target_deps");
}
static void
misplaced:
tprints("???");
- tprints(" /* misplaced struct dm_name_list */");
+ tprints_comment("misplaced struct dm_name_list");
}
static void
misplaced:
tprints("???");
- tprints(" /* misplaced struct dm_target_versions */");
+ tprints_comment("misplaced struct dm_target_versions");
}
static void
tprints("}");
} else {
tprints("???");
- tprints(" /* misplaced struct dm_target_msg */");
+ tprints_comment("misplaced struct dm_target_msg");
}
}
QUOTE_0_TERMINATED);
} else {
tprints("???");
- tprints(" /* misplaced string */");
+ tprints_comment("misplaced string");
}
}
* ioctl fields
*/
if (ioc->version[0] != DM_VERSION_MAJOR) {
- tprints(" /* unsupported device mapper ABI version */");
+ tprints_comment("unsupported device mapper ABI version");
goto skip;
}
tprintf(", data_size=%u", ioc->data_size);
if (ioc->data_size < offsetof(struct dm_ioctl, data)) {
- tprints(" /* data_size too small */");
+ tprints_comment("data_size too small");
goto skip;
}
if (!cp)
break;
}
- tprintf(" /* %u var%s%s */",
+ tprintf_comment("%u var%s%s",
count, count == 1 ? "" : "s",
unterminated ? ", unterminated" : "");
}
const unsigned int val = tcp->u_arg[2];
const unsigned int val2 = tcp->u_arg[3];
const unsigned int val3 = tcp->u_arg[5];
+ const char *comment;
printaddr(uaddr);
tprints(", ");
tprints(", ");
if ((val3 >> 28) & 8)
tprints("FUTEX_OP_OPARG_SHIFT<<28|");
- if (printxval(futexwakeops, (val3 >> 28) & 0x7, NULL))
- tprints("<<28");
- else
- tprints("<<28 /* FUTEX_OP_??? */");
+ comment = printxval(futexwakeops, (val3 >> 28) & 0x7, NULL)
+ ? NULL : "FUTEX_OP_???";
+ tprints("<<28");
+ tprints_comment(comment);
tprintf("|%#x<<12|", (val3 >> 12) & 0xfff);
- if (printxval(futexwakecmps, (val3 >> 24) & 0xf, NULL))
- tprints("<<24");
- else
- tprints("<<24 /* FUTEX_OP_CMP_??? */");
+ comment = printxval(futexwakecmps, (val3 >> 24) & 0xf, NULL)
+ ? NULL : "FUTEX_OP_CMP_???";
+ tprints("<<24");
+ tprints_comment(comment);
tprintf("|%#x", val3 & 0xfff);
break;
case FUTEX_WAIT_REQUEUE_PI:
(attr->config >> 16) & 0xFF,
"PERF_COUNT_HW_CACHE_RESULT_???");
tprints("<<16");
- if (attr->config >> 24)
- tprintf("|%#" PRIx64 "<<24 "
- "/* PERF_COUNT_HW_CACHE_??? */",
- attr->config >> 24);
+ if (attr->config >> 24) {
+ tprintf("|%#" PRIx64 "<<24", attr->config >> 24);
+ tprints_comment("PERF_COUNT_HW_CACHE_???");
+ }
break;
case PERF_TYPE_RAW:
/*
", enable_on_exec=%u"
", task=%u"
", watermark=%u"
- ", precise_ip=%u /* %s */"
- ", mmap_data=%u"
- ", sample_id_all=%u"
- ", exclude_host=%u"
- ", exclude_guest=%u"
- ", exclude_callchain_kernel=%u"
- ", exclude_callchain_user=%u"
- ", mmap2=%u"
- ", comm_exec=%u"
- ", use_clockid=%u"
- ", context_switch=%u"
- ", write_backward=%u",
+ ", precise_ip=%u",
attr->disabled,
attr->inherit,
attr->pinned,
attr->enable_on_exec,
attr->task,
attr->watermark,
- attr->precise_ip, precise_ip_desc[attr->precise_ip],
+ attr->precise_ip);
+ tprints_comment(precise_ip_desc[attr->precise_ip]);
+ tprintf(", mmap_data=%u"
+ ", sample_id_all=%u"
+ ", exclude_host=%u"
+ ", exclude_guest=%u"
+ ", exclude_callchain_kernel=%u"
+ ", exclude_callchain_user=%u"
+ ", mmap2=%u"
+ ", comm_exec=%u"
+ ", use_clockid=%u"
+ ", context_switch=%u"
+ ", write_backward=%u",
attr->mmap_data,
attr->sample_id_all,
attr->exclude_host,
* Print it only in case it is non-zero, since it may contain flags we
* are not aware about.
*/
- if (attr->__reserved_1)
- tprintf(", __reserved_1=%#" PRIx64 " /* Bits 63..28 */",
+ if (attr->__reserved_1) {
+ tprintf(", __reserved_1=%#" PRIx64,
(uint64_t) attr->__reserved_1);
+ tprints_comment("Bits 63..28");
+ }
if (attr->watermark)
tprintf(", wakeup_watermark=%u", attr->wakeup_watermark);
break;
case BPF_ST:
case BPF_STX:
- if (i)
- tprintf("|%#x /* %s */", i, "BPF_???");
+ if (i) {
+ tprintf("|%#x", i);
+ tprints_comment("BPF_???");
+ }
break;
case BPF_ALU:
tprints("|");
tprints("|");
printxval(bpf_rval, BPF_RVAL(code), "BPF_???");
i &= ~BPF_RVAL(code);
- if (i)
- tprintf("|%#x /* %s */", i, "BPF_???");
+ if (i) {
+ tprintf("|%#x", i);
+ tprints_comment("BPF_???");
+ }
break;
case BPF_MISC:
tprints("|");
printxval(bpf_miscop, BPF_MISCOP(code), "BPF_???");
i &= ~BPF_MISCOP(code);
- if (i)
- tprintf("|%#x /* %s */", i, "BPF_???");
+ if (i) {
+ tprintf("|%#x", i);
+ tprints_comment("BPF_???");
+ }
break;
}
return fp;
}
-void
-tprintf(const char *fmt, ...)
+ATTRIBUTE_FORMAT((printf, 1, 0))
+static void
+tvprintf(const char *const fmt, va_list args)
{
- va_list args;
-
- va_start(args, fmt);
if (current_tcp) {
int n = vfprintf(current_tcp->outf, fmt, args);
if (n < 0) {
} else
current_tcp->curcol += n;
}
+}
+
+void
+tprintf(const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ tvprintf(fmt, args);
va_end(args);
}
}
}
+void
+tprints_comment(const char *const str)
+{
+ if (str && *str)
+ tprintf(" /* %s */", str);
+}
+
+void
+tprintf_comment(const char *fmt, ...)
+{
+ if (!fmt || !*fmt)
+ return;
+
+ va_list args;
+ va_start(args, fmt);
+ tprints(" /* ");
+ tvprintf(fmt, args);
+ tprints(" */");
+ va_end(args);
+}
+
void
line_ended(void)
{
const char *name = xlookup(btrfs_dev_stats_values, i);
if (i)
printf(", ");
- if (name)
- printf("/* %s */ ", name);
printf("%" PRI__u64, args.values[i]);
+ if (name)
+ printf(" /* %s */", name);
}
printf("]}) = 0\n");
}
&supported_features);
printf("ioctl(%d, BTRFS_IOC_GET_SUPPORTED_FEATURES, ",
btrfs_test_dir_fd);
- printf("[ /* supported */ ");
+ printf("[");
btrfs_print_features(&supported_features[0]);
- printf(", /* safe to set */ ");
+ printf(" /* supported */, ");
btrfs_print_features(&supported_features[1]);
- printf(", /* safe to clear */ ");
+ printf(" /* safe to set */, ");
btrfs_print_features(&supported_features[2]);
- printf("]) = 0\n");
+ printf(" /* safe to clear */]) = 0\n");
}
}
}
/* No hits -- print raw # instead. */
tprintf("%#" PRIx64, val);
- if (dflt)
- tprintf(" /* %s */", dflt);
+ tprints_comment(dflt);
va_end(args);
}
tprintf("%#" PRIx64, val);
- if (dflt)
- tprintf(" /* %s */", dflt);
+ tprints_comment(dflt);
return 0;
}
} else {
if (flags) {
tprintf("%#" PRIx64, flags);
- if (dflt)
- tprintf(" /* %s */", dflt);
+ tprints_comment(dflt);
} else {
if (dflt)
tprints("0");