[linux-block.git] / tools / perf / util / intel-pt-decoder / intel-pt-log.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * intel_pt_log.c: Intel Processor Trace support
 * Copyright (c) 2013-2014, Intel Corporation.
 */

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdbool.h>
#include <string.h>

#include "intel-pt-log.h"
#include "intel-pt-insn-decoder.h"

#include "intel-pt-pkt-decoder.h"

#define MAX_LOG_NAME 256

static FILE *f;
static char log_name[MAX_LOG_NAME];
bool intel_pt_enable_logging;

void *intel_pt_log_fp(void)
{
	return f;
}

void intel_pt_log_enable(void)
{
	intel_pt_enable_logging = true;
}

void intel_pt_log_disable(void)
{
	if (f)
		fflush(f);
	intel_pt_enable_logging = false;
}

void intel_pt_log_set_name(const char *name)
{
	strncpy(log_name, name, MAX_LOG_NAME - 5);
	strcat(log_name, ".log");
}

static void intel_pt_print_data(const unsigned char *buf, int len, uint64_t pos,
				int indent)
{
	int i;

	for (i = 0; i < indent; i++)
		fprintf(f, " ");

	fprintf(f, "  %08" PRIx64 ": ", pos);
	for (i = 0; i < len; i++)
		fprintf(f, " %02x", buf[i]);
	for (; i < 16; i++)
		fprintf(f, "   ");
	fprintf(f, " ");
}

static void intel_pt_print_no_data(uint64_t pos, int indent)
{
	int i;

	for (i = 0; i < indent; i++)
		fprintf(f, " ");

	fprintf(f, "  %08" PRIx64 ": ", pos);
	for (i = 0; i < 16; i++)
		fprintf(f, "   ");
	fprintf(f, " ");
}

static int intel_pt_log_open(void)
{
	if (!intel_pt_enable_logging)
		return -1;

	if (f)
		return 0;

	if (!log_name[0])
		return -1;

	f = fopen(log_name, "w+");
	if (!f) {
		intel_pt_enable_logging = false;
		return -1;
	}

	return 0;
}

void __intel_pt_log_packet(const struct intel_pt_pkt *packet, int pkt_len,
			   uint64_t pos, const unsigned char *buf)
{
	char desc[INTEL_PT_PKT_DESC_MAX];

	if (intel_pt_log_open())
		return;

	intel_pt_print_data(buf, pkt_len, pos, 0);
	intel_pt_pkt_desc(packet, desc, INTEL_PT_PKT_DESC_MAX);
	fprintf(f, "%s\n", desc);
}

void __intel_pt_log_insn(struct intel_pt_insn *intel_pt_insn, uint64_t ip)
{
	char desc[INTEL_PT_INSN_DESC_MAX];
	size_t len = intel_pt_insn->length;

	if (intel_pt_log_open())
		return;

	if (len > INTEL_PT_INSN_BUF_SZ)
		len = INTEL_PT_INSN_BUF_SZ;
	intel_pt_print_data(intel_pt_insn->buf, len, ip, 8);
	if (intel_pt_insn_desc(intel_pt_insn, desc, INTEL_PT_INSN_DESC_MAX) > 0)
		fprintf(f, "%s\n", desc);
	else
		fprintf(f, "Bad instruction!\n");
}

void __intel_pt_log_insn_no_data(struct intel_pt_insn *intel_pt_insn,
				 uint64_t ip)
{
	char desc[INTEL_PT_INSN_DESC_MAX];

	if (intel_pt_log_open())
		return;

	intel_pt_print_no_data(ip, 8);
	if (intel_pt_insn_desc(intel_pt_insn, desc, INTEL_PT_INSN_DESC_MAX) > 0)
		fprintf(f, "%s\n", desc);
	else
		fprintf(f, "Bad instruction!\n");
}

void __intel_pt_log(const char *fmt, ...)
{
	va_list args;

	if (intel_pt_log_open())
		return;

	va_start(args, fmt);
	vfprintf(f, fmt, args);
	va_end(args);
}
Commit	Line	Data
2025cf9e	1	// SPDX-License-Identifier: GPL-2.0-only
53af9284 AH	2	/*
	3	* intel_pt_log.c: Intel Processor Trace support
	4	* Copyright (c) 2013-2014, Intel Corporation.
53af9284 AH	5	*/
	6
	7	#include <stdio.h>
	8	#include <stdint.h>
	9	#include <inttypes.h>
	10	#include <stdarg.h>
	11	#include <stdbool.h>
	12	#include <string.h>
	13
	14	#include "intel-pt-log.h"
	15	#include "intel-pt-insn-decoder.h"
	16
	17	#include "intel-pt-pkt-decoder.h"
	18
	19	#define MAX_LOG_NAME 256
	20
	21	static FILE *f;
	22	static char log_name[MAX_LOG_NAME];
116f349c	23	bool intel_pt_enable_logging;
53af9284	24
93f8be27 AH	25	void *intel_pt_log_fp(void)
	26	{
	27	return f;
	28	}
	29
53af9284 AH	30	void intel_pt_log_enable(void)
53af9284 AH	31	{
116f349c	32	intel_pt_enable_logging = true;
53af9284 AH	33	}
	34
	35	void intel_pt_log_disable(void)
	36	{
	37	if (f)
	38	fflush(f);
116f349c	39	intel_pt_enable_logging = false;
53af9284 AH	40	}
	41
	42	void intel_pt_log_set_name(const char *name)
	43	{
	44	strncpy(log_name, name, MAX_LOG_NAME - 5);
	45	strcat(log_name, ".log");
	46	}
	47
	48	static void intel_pt_print_data(const unsigned char *buf, int len, uint64_t pos,
	49	int indent)
	50	{
	51	int i;
	52
	53	for (i = 0; i < indent; i++)
	54	fprintf(f, " ");
	55
	56	fprintf(f, " %08" PRIx64 ": ", pos);
	57	for (i = 0; i < len; i++)
	58	fprintf(f, " %02x", buf[i]);
	59	for (; i < 16; i++)
	60	fprintf(f, " ");
	61	fprintf(f, " ");
	62	}
	63
	64	static void intel_pt_print_no_data(uint64_t pos, int indent)
	65	{
	66	int i;
	67
	68	for (i = 0; i < indent; i++)
	69	fprintf(f, " ");
	70
	71	fprintf(f, " %08" PRIx64 ": ", pos);
	72	for (i = 0; i < 16; i++)
	73	fprintf(f, " ");
	74	fprintf(f, " ");
	75	}
	76
	77	static int intel_pt_log_open(void)
	78	{
116f349c	79	if (!intel_pt_enable_logging)
53af9284 AH	80	return -1;
	81
	82	if (f)
	83	return 0;
	84
	85	if (!log_name[0])
	86	return -1;
	87
	88	f = fopen(log_name, "w+");
	89	if (!f) {
116f349c	90	intel_pt_enable_logging = false;
53af9284 AH	91	return -1;
	92	}
	93
	94	return 0;
	95	}
	96
116f349c AH	97	void __intel_pt_log_packet(const struct intel_pt_pkt *packet, int pkt_len,
116f349c AH	98	uint64_t pos, const unsigned char *buf)
53af9284 AH	99	{
	100	char desc[INTEL_PT_PKT_DESC_MAX];
	101
	102	if (intel_pt_log_open())
	103	return;
	104
	105	intel_pt_print_data(buf, pkt_len, pos, 0);
	106	intel_pt_pkt_desc(packet, desc, INTEL_PT_PKT_DESC_MAX);
	107	fprintf(f, "%s\n", desc);
	108	}
	109
116f349c	110	void __intel_pt_log_insn(struct intel_pt_insn *intel_pt_insn, uint64_t ip)
53af9284 AH	111	{
	112	char desc[INTEL_PT_INSN_DESC_MAX];
	113	size_t len = intel_pt_insn->length;
	114
	115	if (intel_pt_log_open())
	116	return;
	117
32f98aab AH	118	if (len > INTEL_PT_INSN_BUF_SZ)
32f98aab AH	119	len = INTEL_PT_INSN_BUF_SZ;
53af9284 AH	120	intel_pt_print_data(intel_pt_insn->buf, len, ip, 8);
	121	if (intel_pt_insn_desc(intel_pt_insn, desc, INTEL_PT_INSN_DESC_MAX) > 0)
	122	fprintf(f, "%s\n", desc);
	123	else
	124	fprintf(f, "Bad instruction!\n");
	125	}
	126
116f349c AH	127	void __intel_pt_log_insn_no_data(struct intel_pt_insn *intel_pt_insn,
116f349c AH	128	uint64_t ip)
53af9284 AH	129	{
	130	char desc[INTEL_PT_INSN_DESC_MAX];
	131
	132	if (intel_pt_log_open())
	133	return;
	134
	135	intel_pt_print_no_data(ip, 8);
	136	if (intel_pt_insn_desc(intel_pt_insn, desc, INTEL_PT_INSN_DESC_MAX) > 0)
	137	fprintf(f, "%s\n", desc);
	138	else
	139	fprintf(f, "Bad instruction!\n");
	140	}
	141
116f349c	142	void __intel_pt_log(const char *fmt, ...)
53af9284 AH	143	{
	144	va_list args;
	145
	146	if (intel_pt_log_open())
	147	return;
	148
	149	va_start(args, fmt);
	150	vfprintf(f, fmt, args);
	151	va_end(args);
	152	}