[linux-2.6-block.git] / tools / perf / util / debug.c

// SPDX-License-Identifier: GPL-2.0
/* For general debugging purposes */

#include <inttypes.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <api/debug.h>
#include <linux/kernel.h>
#include <linux/time64.h>
#include <sys/time.h>
#ifdef HAVE_BACKTRACE_SUPPORT
#include <execinfo.h>
#endif
#include "color.h"
#include "event.h"
#include "debug.h"
#include "print_binary.h"
#include "target.h"
#include "trace-event.h"
#include "ui/helpline.h"
#include "ui/ui.h"
#include "util/parse-sublevel-options.h"

#include <linux/ctype.h>

#ifdef HAVE_LIBTRACEEVENT
#include <event-parse.h>
#else
#define LIBTRACEEVENT_VERSION 0
#endif

int verbose;
int debug_kmaps;
int debug_peo_args;
bool dump_trace = false, quiet = false;
int debug_ordered_events;
static int redirect_to_stderr;
int debug_data_convert;
static FILE *_debug_file;
bool debug_display_time;
int debug_type_profile;

FILE *debug_file(void)
{
	if (!_debug_file) {
		debug_set_file(stderr);
		pr_warning_once("debug_file not set");
	}
	return _debug_file;
}

void debug_set_file(FILE *file)
{
	_debug_file = file;
}

void debug_set_display_time(bool set)
{
	debug_display_time = set;
}

static int fprintf_time(FILE *file)
{
	struct timeval tod;
	struct tm ltime;
	char date[64];

	if (!debug_display_time)
		return 0;

	if (gettimeofday(&tod, NULL) != 0)
		return 0;

	if (localtime_r(&tod.tv_sec, &ltime) == NULL)
		return 0;

	strftime(date, sizeof(date),  "%F %H:%M:%S", &ltime);
	return fprintf(file, "[%s.%06lu] ", date, (long)tod.tv_usec);
}

int veprintf(int level, int var, const char *fmt, va_list args)
{
	int ret = 0;

	if (var >= level) {
		if (use_browser >= 1 && !redirect_to_stderr) {
			ui_helpline__vshow(fmt, args);
		} else {
			ret = fprintf_time(debug_file());
			ret += vfprintf(debug_file(), fmt, args);
		}
	}

	return ret;
}

int eprintf(int level, int var, const char *fmt, ...)
{
	va_list args;
	int ret;

	va_start(args, fmt);
	ret = veprintf(level, var, fmt, args);
	va_end(args);

	return ret;
}

static int veprintf_time(u64 t, const char *fmt, va_list args)
{
	int ret = 0;
	u64 secs, usecs, nsecs = t;

	secs   = nsecs / NSEC_PER_SEC;
	nsecs -= secs  * NSEC_PER_SEC;
	usecs  = nsecs / NSEC_PER_USEC;

	ret = fprintf(debug_file(), "[%13" PRIu64 ".%06" PRIu64 "] ", secs, usecs);
	ret += vfprintf(debug_file(), fmt, args);
	return ret;
}

int eprintf_time(int level, int var, u64 t, const char *fmt, ...)
{
	int ret = 0;
	va_list args;

	if (var >= level) {
		va_start(args, fmt);
		ret = veprintf_time(t, fmt, args);
		va_end(args);
	}

	return ret;
}

/*
 * Overloading libtraceevent standard info print
 * function, display with -v in perf.
 */
void pr_stat(const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	veprintf(1, verbose, fmt, args);
	va_end(args);
	eprintf(1, verbose, "\n");
}

int dump_printf(const char *fmt, ...)
{
	va_list args;
	int ret = 0;

	if (dump_trace) {
		va_start(args, fmt);
		ret = vprintf(fmt, args);
		va_end(args);
	}

	return ret;
}

static int trace_event_printer(enum binary_printer_ops op,
			       unsigned int val, void *extra, FILE *fp)
{
	const char *color = PERF_COLOR_BLUE;
	union perf_event *event = (union perf_event *)extra;
	unsigned char ch = (unsigned char)val;
	int printed = 0;

	switch (op) {
	case BINARY_PRINT_DATA_BEGIN:
		printed += fprintf(fp, ".");
		printed += color_fprintf(fp, color, "\n. ... raw event: size %d bytes\n",
					 event->header.size);
		break;
	case BINARY_PRINT_LINE_BEGIN:
		printed += fprintf(fp, ".");
		break;
	case BINARY_PRINT_ADDR:
		printed += color_fprintf(fp, color, "  %04x: ", val);
		break;
	case BINARY_PRINT_NUM_DATA:
		printed += color_fprintf(fp, color, " %02x", val);
		break;
	case BINARY_PRINT_NUM_PAD:
		printed += color_fprintf(fp, color, "   ");
		break;
	case BINARY_PRINT_SEP:
		printed += color_fprintf(fp, color, "  ");
		break;
	case BINARY_PRINT_CHAR_DATA:
		printed += color_fprintf(fp, color, "%c",
			      isprint(ch) && isascii(ch) ? ch : '.');
		break;
	case BINARY_PRINT_CHAR_PAD:
		printed += color_fprintf(fp, color, " ");
		break;
	case BINARY_PRINT_LINE_END:
		printed += color_fprintf(fp, color, "\n");
		break;
	case BINARY_PRINT_DATA_END:
		printed += fprintf(fp, "\n");
		break;
	default:
		break;
	}

	return printed;
}

void trace_event(union perf_event *event)
{
	unsigned char *raw_event = (void *)event;

	if (!dump_trace)
		return;

	print_binary(raw_event, event->header.size, 16,
		     trace_event_printer, event);
}

static struct sublevel_option debug_opts[] = {
	{ .name = "verbose",		.value_ptr = &verbose },
	{ .name = "ordered-events",	.value_ptr = &debug_ordered_events},
	{ .name = "stderr",		.value_ptr = &redirect_to_stderr},
	{ .name = "data-convert",	.value_ptr = &debug_data_convert },
	{ .name = "perf-event-open",	.value_ptr = &debug_peo_args },
	{ .name = "kmaps",		.value_ptr = &debug_kmaps },
	{ .name = "type-profile",	.value_ptr = &debug_type_profile },
	{ .name = NULL, }
};

int perf_debug_option(const char *str)
{
	int ret;

	ret = perf_parse_sublevel_options(str, debug_opts);
	if (ret)
		return ret;

	/* Allow only verbose value in range (0, 10), otherwise set 0. */
	verbose = (verbose < 0) || (verbose > 10) ? 0 : verbose;

#if LIBTRACEEVENT_VERSION >= MAKE_LIBTRACEEVENT_VERSION(1, 3, 0)
	if (verbose == 1)
		tep_set_loglevel(TEP_LOG_INFO);
	else if (verbose == 2)
		tep_set_loglevel(TEP_LOG_DEBUG);
	else if (verbose >= 3)
		tep_set_loglevel(TEP_LOG_ALL);
#endif
	return 0;
}

int perf_quiet_option(void)
{
	struct sublevel_option *opt = &debug_opts[0];

	/* disable all debug messages */
	while (opt->name) {
		*opt->value_ptr = -1;
		opt++;
	}

	/* For debug variables that are used as bool types, set to 0. */
	redirect_to_stderr = 0;
	debug_peo_args = 0;
	debug_kmaps = 0;
	debug_type_profile = 0;

	return 0;
}

#define DEBUG_WRAPPER(__n, __l)				\
static int pr_ ## __n ## _wrapper(const char *fmt, ...)	\
{							\
	va_list args;					\
	int ret;					\
							\
	va_start(args, fmt);				\
	ret = veprintf(__l, verbose, fmt, args);	\
	va_end(args);					\
	return ret;					\
}

DEBUG_WRAPPER(warning, 0);
DEBUG_WRAPPER(debug, 1);

void perf_debug_setup(void)
{
	debug_set_file(stderr);
	libapi_set_print(pr_warning_wrapper, pr_warning_wrapper, pr_debug_wrapper);
}

/* Obtain a backtrace and print it to stdout. */
#ifdef HAVE_BACKTRACE_SUPPORT
void dump_stack(void)
{
	void *array[16];
	size_t size = backtrace(array, ARRAY_SIZE(array));
	char **strings = backtrace_symbols(array, size);
	size_t i;

	printf("Obtained %zd stack frames.\n", size);

	for (i = 0; i < size; i++)
		printf("%s\n", strings[i]);

	free(strings);
}
#else
void dump_stack(void) {}
#endif

void sighandler_dump_stack(int sig)
{
	psignal(sig, "perf");
	dump_stack();
	signal(sig, SIG_DFL);
	raise(sig);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
cd84c2ac FW	2	/* For general debugging purposes */
cd84c2ac FW	3
fd20e811	4	#include <inttypes.h>
cd84c2ac FW	5	#include <string.h>
	6	#include <stdarg.h>
	7	#include <stdio.h>
215a0d30	8	#include <stdlib.h>
4208735d	9	#include <sys/wait.h>
dd629cc0	10	#include <api/debug.h>
4cb3c6d5	11	#include <linux/kernel.h>
bd48c63e	12	#include <linux/time64.h>
bcbd79d1	13	#include <sys/time.h>
8c2b7cac ACM	14	#ifdef HAVE_BACKTRACE_SUPPORT
	15	#include <execinfo.h>
	16	#endif
8f28827a FW	17	#include "color.h"
	18	#include "event.h"
	19	#include "debug.h"
fea01392	20	#include "print_binary.h"
16ad2ffb	21	#include "target.h"
316769f7	22	#include "trace-event.h"
8520a98d	23	#include "ui/helpline.h"
fa0d9846	24	#include "ui/ui.h"
a80abe2a	25	#include "util/parse-sublevel-options.h"
8f28827a	26
3052ba56	27	#include <linux/ctype.h>
3d689ed6	28
316769f7	29	#ifdef HAVE_LIBTRACEEVENT
35de42cd	30	#include <event-parse.h>
316769f7 IR	31	#else
	32	#define LIBTRACEEVENT_VERSION 0
	33	#endif
	34
b44308f5	35	int verbose;
0bdfbd04	36	int debug_kmaps;
ccd26741	37	int debug_peo_args;
b44308f5	38	bool dump_trace = false, quiet = false;
cee3ab9c	39	int debug_ordered_events;
f78eaef0	40	static int redirect_to_stderr;
edbe9817	41	int debug_data_convert;
ec49230c	42	static FILE *_debug_file;
bcbd79d1	43	bool debug_display_time;
90429524	44	int debug_type_profile;
8abceacf	45
ec49230c IR	46	FILE *debug_file(void)
	47	{
	48	if (!_debug_file) {
ec49230c	49	debug_set_file(stderr);
bda84019	50	pr_warning_once("debug_file not set");
ec49230c IR	51	}
	52	return _debug_file;
	53	}
	54
8abceacf JO	55	void debug_set_file(FILE *file)
8abceacf JO	56	{
ec49230c	57	_debug_file = file;
8abceacf	58	}
cd84c2ac	59
bcbd79d1 JO	60	void debug_set_display_time(bool set)
	61	{
	62	debug_display_time = set;
	63	}
	64
	65	static int fprintf_time(FILE *file)
	66	{
	67	struct timeval tod;
	68	struct tm ltime;
	69	char date[64];
	70
	71	if (!debug_display_time)
	72	return 0;
	73
	74	if (gettimeofday(&tod, NULL) != 0)
	75	return 0;
	76
	77	if (localtime_r(&tod.tv_sec, &ltime) == NULL)
	78	return 0;
	79
	80	strftime(date, sizeof(date), "%F %H:%M:%S", &ltime);
	81	return fprintf(file, "[%s.%06lu] ", date, (long)tod.tv_usec);
	82	}
	83
bedbdd42	84	int veprintf(int level, int var, const char *fmt, va_list args)
cd84c2ac	85	{
cd84c2ac FW	86	int ret = 0;
cd84c2ac FW	87
c95688aa	88	if (var >= level) {
bcbd79d1	89	if (use_browser >= 1 && !redirect_to_stderr) {
b56e5331	90	ui_helpline__vshow(fmt, args);
bcbd79d1	91	} else {
ec49230c IR	92	ret = fprintf_time(debug_file());
ec49230c IR	93	ret += vfprintf(debug_file(), fmt, args);
bcbd79d1	94	}
cd84c2ac FW	95	}
	96
	97	return ret;
	98	}
2cec19d9	99
c95688aa	100	int eprintf(int level, int var, const char *fmt, ...)
f772abc6 JO	101	{
	102	va_list args;
	103	int ret;
	104
	105	va_start(args, fmt);
bedbdd42	106	ret = veprintf(level, var, fmt, args);
f772abc6 JO	107	va_end(args);
	108
	109	return ret;
	110	}
	111
bedbdd42	112	static int veprintf_time(u64 t, const char *fmt, va_list args)
cee3ab9c JO	113	{
	114	int ret = 0;
	115	u64 secs, usecs, nsecs = t;
	116
bd48c63e ACM	117	secs = nsecs / NSEC_PER_SEC;
	118	nsecs -= secs * NSEC_PER_SEC;
	119	usecs = nsecs / NSEC_PER_USEC;
cee3ab9c	120
ec49230c IR	121	ret = fprintf(debug_file(), "[%13" PRIu64 ".%06" PRIu64 "] ", secs, usecs);
ec49230c IR	122	ret += vfprintf(debug_file(), fmt, args);
cee3ab9c JO	123	return ret;
	124	}
	125
	126	int eprintf_time(int level, int var, u64 t, const char *fmt, ...)
	127	{
	128	int ret = 0;
	129	va_list args;
	130
	131	if (var >= level) {
	132	va_start(args, fmt);
bedbdd42	133	ret = veprintf_time(t, fmt, args);
cee3ab9c JO	134	va_end(args);
	135	}
	136
	137	return ret;
	138	}
	139
f772abc6 JO	140	/*
	141	* Overloading libtraceevent standard info print
	142	* function, display with -v in perf.
	143	*/
	144	void pr_stat(const char *fmt, ...)
	145	{
	146	va_list args;
	147
	148	va_start(args, fmt);
bedbdd42	149	veprintf(1, verbose, fmt, args);
f772abc6	150	va_end(args);
c95688aa	151	eprintf(1, verbose, "\n");
f772abc6 JO	152	}
f772abc6 JO	153
2cec19d9 FW	154	int dump_printf(const char *fmt, ...)
	155	{
	156	va_list args;
	157	int ret = 0;
	158
	159	if (dump_trace) {
	160	va_start(args, fmt);
	161	ret = vprintf(fmt, args);
	162	va_end(args);
	163	}
	164
	165	return ret;
	166	}
8f28827a	167
923d0c9a ACM	168	static int trace_event_printer(enum binary_printer_ops op,
923d0c9a ACM	169	unsigned int val, void extra, FILE fp)
c339b1a9 WN	170	{
	171	const char *color = PERF_COLOR_BLUE;
	172	union perf_event event = (union perf_event )extra;
	173	unsigned char ch = (unsigned char)val;
923d0c9a	174	int printed = 0;
c339b1a9 WN	175
	176	switch (op) {
	177	case BINARY_PRINT_DATA_BEGIN:
923d0c9a ACM	178	printed += fprintf(fp, ".");
	179	printed += color_fprintf(fp, color, "\n. ... raw event: size %d bytes\n",
	180	event->header.size);
c339b1a9 WN	181	break;
c339b1a9 WN	182	case BINARY_PRINT_LINE_BEGIN:
923d0c9a	183	printed += fprintf(fp, ".");
c339b1a9 WN	184	break;
c339b1a9 WN	185	case BINARY_PRINT_ADDR:
923d0c9a	186	printed += color_fprintf(fp, color, " %04x: ", val);
c339b1a9 WN	187	break;
c339b1a9 WN	188	case BINARY_PRINT_NUM_DATA:
923d0c9a	189	printed += color_fprintf(fp, color, " %02x", val);
c339b1a9 WN	190	break;
c339b1a9 WN	191	case BINARY_PRINT_NUM_PAD:
923d0c9a	192	printed += color_fprintf(fp, color, " ");
c339b1a9 WN	193	break;
c339b1a9 WN	194	case BINARY_PRINT_SEP:
923d0c9a	195	printed += color_fprintf(fp, color, " ");
c339b1a9 WN	196	break;
c339b1a9 WN	197	case BINARY_PRINT_CHAR_DATA:
923d0c9a	198	printed += color_fprintf(fp, color, "%c",
62942e9f	199	isprint(ch) && isascii(ch) ? ch : '.');
c339b1a9 WN	200	break;
c339b1a9 WN	201	case BINARY_PRINT_CHAR_PAD:
923d0c9a	202	printed += color_fprintf(fp, color, " ");
c339b1a9 WN	203	break;
c339b1a9 WN	204	case BINARY_PRINT_LINE_END:
923d0c9a	205	printed += color_fprintf(fp, color, "\n");
c339b1a9 WN	206	break;
c339b1a9 WN	207	case BINARY_PRINT_DATA_END:
923d0c9a	208	printed += fprintf(fp, "\n");
c339b1a9 WN	209	break;
	210	default:
	211	break;
	212	}
923d0c9a ACM	213
923d0c9a ACM	214	return printed;
c339b1a9 WN	215	}
c339b1a9 WN	216
8115d60c	217	void trace_event(union perf_event *event)
8f28827a FW	218	{
8f28827a FW	219	unsigned char raw_event = (void )event;
8f28827a FW	220
	221	if (!dump_trace)
	222	return;
	223
c339b1a9 WN	224	print_binary(raw_event, event->header.size, 16,
c339b1a9 WN	225	trace_event_printer, event);
8f28827a	226	}
bbb2cea7	227
a80abe2a CD	228	static struct sublevel_option debug_opts[] = {
	229	{ .name = "verbose", .value_ptr = &verbose },
	230	{ .name = "ordered-events", .value_ptr = &debug_ordered_events},
	231	{ .name = "stderr", .value_ptr = &redirect_to_stderr},
	232	{ .name = "data-convert", .value_ptr = &debug_data_convert },
	233	{ .name = "perf-event-open", .value_ptr = &debug_peo_args },
0bdfbd04	234	{ .name = "kmaps", .value_ptr = &debug_kmaps },
90429524	235	{ .name = "type-profile", .value_ptr = &debug_type_profile },
bbb2cea7 JO	236	{ .name = NULL, }
	237	};
	238
	239	int perf_debug_option(const char *str)
	240	{
a80abe2a	241	int ret;
bbb2cea7	242
a80abe2a CD	243	ret = perf_parse_sublevel_options(str, debug_opts);
	244	if (ret)
	245	return ret;
bbb2cea7	246
a80abe2a CD	247	/* Allow only verbose value in range (0, 10), otherwise set 0. */
a80abe2a CD	248	verbose = (verbose < 0) \|\| (verbose > 10) ? 0 : verbose;
80df1988	249
316769f7 IR	250	#if LIBTRACEEVENT_VERSION >= MAKE_LIBTRACEEVENT_VERSION(1, 3, 0)
	251	if (verbose == 1)
	252	tep_set_loglevel(TEP_LOG_INFO);
	253	else if (verbose == 2)
	254	tep_set_loglevel(TEP_LOG_DEBUG);
	255	else if (verbose >= 3)
	256	tep_set_loglevel(TEP_LOG_ALL);
	257	#endif
bbb2cea7 JO	258	return 0;
bbb2cea7 JO	259	}
dd629cc0	260
80df1988 NK	261	int perf_quiet_option(void)
80df1988 NK	262	{
a80abe2a	263	struct sublevel_option *opt = &debug_opts[0];
80df1988 NK	264
80df1988 NK	265	/* disable all debug messages */
a80abe2a CD	266	while (opt->name) {
	267	*opt->value_ptr = -1;
	268	opt++;
80df1988 NK	269	}
80df1988 NK	270
188ac720 YJ	271	/* For debug variables that are used as bool types, set to 0. */
	272	redirect_to_stderr = 0;
	273	debug_peo_args = 0;
0bdfbd04	274	debug_kmaps = 0;
90429524	275	debug_type_profile = 0;
188ac720	276
80df1988 NK	277	return 0;
	278	}
	279
dd629cc0 JO	280	#define DEBUG_WRAPPER(__n, __l) \
	281	static int pr_ ## __n ## _wrapper(const char *fmt, ...) \
	282	{ \
	283	va_list args; \
	284	int ret; \
	285	\
	286	va_start(args, fmt); \
	287	ret = veprintf(__l, verbose, fmt, args); \
	288	va_end(args); \
	289	return ret; \
	290	}
	291
	292	DEBUG_WRAPPER(warning, 0);
	293	DEBUG_WRAPPER(debug, 1);
	294
	295	void perf_debug_setup(void)
	296	{
8abceacf	297	debug_set_file(stderr);
dd629cc0 JO	298	libapi_set_print(pr_warning_wrapper, pr_warning_wrapper, pr_debug_wrapper);
dd629cc0 JO	299	}
8c2b7cac ACM	300
	301	/* Obtain a backtrace and print it to stdout. */
	302	#ifdef HAVE_BACKTRACE_SUPPORT
	303	void dump_stack(void)
	304	{
	305	void *array[16];
	306	size_t size = backtrace(array, ARRAY_SIZE(array));
	307	char **strings = backtrace_symbols(array, size);
	308	size_t i;
	309
	310	printf("Obtained %zd stack frames.\n", size);
	311
	312	for (i = 0; i < size; i++)
	313	printf("%s\n", strings[i]);
	314
	315	free(strings);
	316	}
	317	#else
	318	void dump_stack(void) {}
	319	#endif
	320
	321	void sighandler_dump_stack(int sig)
	322	{
	323	psignal(sig, "perf");
	324	dump_stack();
	325	signal(sig, SIG_DFL);
	326	raise(sig);
	327	}