[u-boot.git] / lib / trace.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2012 The Chromium OS Authors.
 */

#include <mapmem.h>
#include <time.h>
#include <trace.h>
#include <linux/errno.h>
#include <asm/global_data.h>
#include <asm/io.h>
#include <asm/sections.h>

DECLARE_GLOBAL_DATA_PTR;

static char trace_enabled __section(".data");
static char trace_inited __section(".data");

/* The header block at the start of the trace memory area */
struct trace_hdr {
	int func_count;		/* Total number of function call sites */
	u64 call_count;		/* Total number of tracked function calls */
	u64 untracked_count;	/* Total number of untracked function calls */
	int funcs_used;		/* Total number of functions used */

	/*
	 * Call count for each function. This is indexed by the word offset
	 * of the function from gd->relocaddr
	 */
	uintptr_t *call_accum;

	/* Function trace list */
	struct trace_call *ftrace;	/* The function call records */
	ulong ftrace_size;	/* Num. of ftrace records we have space for */
	ulong ftrace_count;	/* Num. of ftrace records written */
	ulong ftrace_too_deep_count;	/* Functions that were too deep */

	int depth;		/* Depth of function calls */
	int depth_limit;	/* Depth limit to trace to */
	int max_depth;		/* Maximum depth seen so far */
	int min_depth;		/* Minimum depth seen so far */
	bool trace_locked;	/* Used to detect recursive tracing */
};

/* Pointer to start of trace buffer */
static struct trace_hdr *hdr __section(".data");

static inline uintptr_t __attribute__((no_instrument_function))
		func_ptr_to_num(void *func_ptr)
{
	uintptr_t offset = (uintptr_t)func_ptr;

#ifdef CONFIG_SANDBOX
	offset -= (uintptr_t)_init;
#else
	if (gd->flags & GD_FLG_RELOC)
		offset -= gd->relocaddr;
	else
		offset -= CONFIG_TEXT_BASE;
#endif
	return offset / FUNC_SITE_SIZE;
}

#if defined(CONFIG_EFI_LOADER) && (defined(CONFIG_ARM) || defined(CONFIG_RISCV))

/**
 * trace_gd - the value of the gd register
 */
static volatile gd_t *trace_gd;

/**
 * trace_save_gd() - save the value of the gd register
 */
static void notrace trace_save_gd(void)
{
	trace_gd = gd;
}

/**
 * trace_swap_gd() - swap between U-Boot and application gd register value
 *
 * An UEFI application may change the value of the register that gd lives in.
 * But some of our functions like get_ticks() access this register. So we
 * have to set the gd register to the U-Boot value when entering a trace
 * point and set it back to the application value when exiting the trace point.
 */
static void notrace trace_swap_gd(void)
{
	volatile gd_t *temp_gd = trace_gd;

	trace_gd = gd;
	set_gd(temp_gd);
}

#else

static void notrace trace_save_gd(void)
{
}

static void notrace trace_swap_gd(void)
{
}

#endif

static void notrace add_ftrace(void *func_ptr, void *caller, ulong flags)
{
	if (hdr->depth > hdr->depth_limit) {
		hdr->ftrace_too_deep_count++;
		return;
	}
	if (hdr->ftrace_count < hdr->ftrace_size) {
		struct trace_call *rec = &hdr->ftrace[hdr->ftrace_count];

		rec->func = func_ptr_to_num(func_ptr);
		rec->caller = func_ptr_to_num(caller);
		rec->flags = flags | (timer_get_us() & FUNCF_TIMESTAMP_MASK);
	}
	hdr->ftrace_count++;
}

/**
 * __cyg_profile_func_enter() - record function entry
 *
 * We add to our tally for this function and add to the list of called
 * functions.
 *
 * @func_ptr:	pointer to function being entered
 * @caller:	pointer to function which called this function
 */
void notrace __cyg_profile_func_enter(void *func_ptr, void *caller)
{
	if (trace_enabled) {
		int func;

		if (hdr->trace_locked) {
			trace_enabled = 0;
			puts("trace: recursion detected, disabling\n");
			hdr->trace_locked = false;
			return;
		}

		hdr->trace_locked = true;
		trace_swap_gd();
		add_ftrace(func_ptr, caller, FUNCF_ENTRY);
		func = func_ptr_to_num(func_ptr);
		if (func < hdr->func_count) {
			hdr->call_accum[func]++;
			hdr->call_count++;
		} else {
			hdr->untracked_count++;
		}
		hdr->depth++;
		if (hdr->depth > hdr->max_depth)
			hdr->max_depth = hdr->depth;
		trace_swap_gd();
		hdr->trace_locked = false;
	}
}

/**
 * __cyg_profile_func_exit() - record function exit
 *
 * @func_ptr:	pointer to function being entered
 * @caller:	pointer to function which called this function
 */
void notrace __cyg_profile_func_exit(void *func_ptr, void *caller)
{
	if (trace_enabled) {
		trace_swap_gd();
		hdr->depth--;
		add_ftrace(func_ptr, caller, FUNCF_EXIT);
		if (hdr->depth < hdr->min_depth)
			hdr->min_depth = hdr->depth;
		trace_swap_gd();
	}
}

/**
 * trace_list_functions() - produce a list of called functions
 *
 * The information is written into the supplied buffer - a header followed
 * by a list of function records.
 *
 * @buff:	buffer to place list into
 * @buff_size:	size of buffer
 * @needed:	returns size of buffer needed, which may be
 *		greater than buff_size if we ran out of space.
 * Return:	0 if ok, -ENOSPC if space was exhausted
 */
int trace_list_functions(void *buff, size_t buff_size, size_t *needed)
{
	struct trace_output_hdr *output_hdr = NULL;
	void *end, *ptr = buff;
	size_t func;
	size_t upto;

	end = buff ? buff + buff_size : NULL;

	/* Place some header information */
	if (ptr + sizeof(struct trace_output_hdr) < end)
		output_hdr = ptr;
	ptr += sizeof(struct trace_output_hdr);

	/* Add information about each function */
	for (func = upto = 0; func < hdr->func_count; func++) {
		size_t calls = hdr->call_accum[func];

		if (!calls)
			continue;

		if (ptr + sizeof(struct trace_output_func) < end) {
			struct trace_output_func *stats = ptr;

			stats->offset = func * FUNC_SITE_SIZE;
			stats->call_count = calls;
			upto++;
		}
		ptr += sizeof(struct trace_output_func);
	}

	/* Update the header */
	if (output_hdr) {
		output_hdr->rec_count = upto;
		output_hdr->type = TRACE_CHUNK_FUNCS;
	}

	/* Work out how must of the buffer we used */
	*needed = ptr - buff;
	if (ptr > end)
		return -ENOSPC;

	return 0;
}

/**
 * trace_list_functions() - produce a list of function calls
 *
 * The information is written into the supplied buffer - a header followed
 * by a list of function records.
 *
 * @buff:	buffer to place list into
 * @buff_size:	size of buffer
 * @needed:	returns size of buffer needed, which may be
 *		greater than buff_size if we ran out of space.
 * Return:	0 if ok, -ENOSPC if space was exhausted
 */
int trace_list_calls(void *buff, size_t buff_size, size_t *needed)
{
	struct trace_output_hdr *output_hdr = NULL;
	void *end, *ptr = buff;
	size_t rec, upto;
	size_t count;

	end = buff ? buff + buff_size : NULL;

	/* Place some header information */
	if (ptr + sizeof(struct trace_output_hdr) < end)
		output_hdr = ptr;
	ptr += sizeof(struct trace_output_hdr);

	/* Add information about each call */
	count = hdr->ftrace_count;
	if (count > hdr->ftrace_size)
		count = hdr->ftrace_size;
	for (rec = upto = 0; rec < count; rec++) {
		if (ptr + sizeof(struct trace_call) < end) {
			struct trace_call *call = &hdr->ftrace[rec];
			struct trace_call *out = ptr;

			out->func = call->func * FUNC_SITE_SIZE;
			out->caller = call->caller * FUNC_SITE_SIZE;
			out->flags = call->flags;
			upto++;
		}
		ptr += sizeof(struct trace_call);
	}

	/* Update the header */
	if (output_hdr) {
		memset(output_hdr, '\0', sizeof(*output_hdr));
		output_hdr->rec_count = upto;
		output_hdr->type = TRACE_CHUNK_CALLS;
		output_hdr->version = TRACE_VERSION;
		output_hdr->text_base = CONFIG_TEXT_BASE;
	}

	/* Work out how must of the buffer we used */
	*needed = ptr - buff;
	if (ptr > end)
		return -ENOSPC;

	return 0;
}

/**
 * trace_print_stats() - print basic information about tracing
 */
void trace_print_stats(void)
{
	ulong count;

#ifndef FTRACE
	puts("Warning: make U-Boot with FTRACE to enable function instrumenting.\n");
	puts("You will likely get zeroed data here\n");
#endif
	if (!trace_inited) {
		printf("Trace is disabled\n");
		return;
	}
	print_grouped_ull(hdr->func_count, 10);
	puts(" function sites\n");
	print_grouped_ull(hdr->call_count, 10);
	puts(" function calls\n");
	print_grouped_ull(hdr->untracked_count, 10);
	puts(" untracked function calls\n");
	count = min(hdr->ftrace_count, hdr->ftrace_size);
	print_grouped_ull(count, 10);
	puts(" traced function calls");
	if (hdr->ftrace_count > hdr->ftrace_size) {
		printf(" (%lu dropped due to overflow)",
		       hdr->ftrace_count - hdr->ftrace_size);
	}

	/* Add in minimum depth since the trace did not start at top level */
	printf("\n%15d maximum observed call depth\n",
	       hdr->max_depth - hdr->min_depth);
	printf("%15d call depth limit\n", hdr->depth_limit);
	print_grouped_ull(hdr->ftrace_too_deep_count, 10);
	puts(" calls not traced due to depth\n");
	print_grouped_ull(hdr->ftrace_size, 10);
	puts(" max function calls\n");
	printf("\ntrace buffer %lx call records %lx\n",
	       (ulong)map_to_sysmem(hdr), (ulong)map_to_sysmem(hdr->ftrace));
}

void notrace trace_set_enabled(int enabled)
{
	trace_enabled = enabled != 0;
}

static int get_func_count(void)
{
	/* Detect no support for mon_len since this means tracing cannot work */
	if (IS_ENABLED(CONFIG_SANDBOX) && !gd->mon_len) {
		puts("Tracing is not supported on this board\n");
		return -ENOTSUPP;
	}

	return gd->mon_len / FUNC_SITE_SIZE;
}

/**
 * trace_init() - initialize the tracing system and enable it
 *
 * @buff:	Pointer to trace buffer
 * @buff_size:	Size of trace buffer
 * Return:	0 if ok
 */
int notrace trace_init(void *buff, size_t buff_size)
{
	int func_count = get_func_count();
	size_t needed;
	int was_disabled = !trace_enabled;

	if (func_count < 0)
		return func_count;
	trace_save_gd();

	if (!was_disabled) {
#ifdef CONFIG_TRACE_EARLY
		ulong used, count;
		char *end;

		/*
		 * Copy over the early trace data if we have it. Disable
		 * tracing while we are doing this.
		 */
		trace_enabled = 0;
		hdr = map_sysmem(CONFIG_TRACE_EARLY_ADDR,
				 CONFIG_TRACE_EARLY_SIZE);
		count = min(hdr->ftrace_count, hdr->ftrace_size);
		end = (char *)&hdr->ftrace[count];
		used = end - (char *)hdr;
		printf("trace: copying %08lx bytes of early data from %x to %08lx\n",
		       used, CONFIG_TRACE_EARLY_ADDR,
		       (ulong)map_to_sysmem(buff));
		printf("%lu traced function calls", count);
		if (hdr->ftrace_count > hdr->ftrace_size) {
			printf(" (%lu dropped due to overflow)",
			       hdr->ftrace_count - hdr->ftrace_size);
			hdr->ftrace_count = hdr->ftrace_size;
		}
		puts("\n");
		memcpy(buff, hdr, used);
#else
		puts("trace: already enabled\n");
		return -EALREADY;
#endif
	}
	hdr = (struct trace_hdr *)buff;
	needed = sizeof(*hdr) + func_count * sizeof(uintptr_t);
	if (needed > buff_size) {
		printf("trace: buffer size %zx bytes: at least %zx needed\n",
		       buff_size, needed);
		return -ENOSPC;
	}

	if (was_disabled) {
		memset(hdr, '\0', needed);
		hdr->min_depth = INT_MAX;
	}
	hdr->func_count = func_count;
	hdr->call_accum = (uintptr_t *)(hdr + 1);

	/* Use any remaining space for the timed function trace */
	hdr->ftrace = (struct trace_call *)(buff + needed);
	hdr->ftrace_size = (buff_size - needed) / sizeof(*hdr->ftrace);
	hdr->depth_limit = CONFIG_TRACE_CALL_DEPTH_LIMIT;

	puts("trace: enabled\n");
	trace_enabled = 1;
	trace_inited = 1;

	return 0;
}

#ifdef CONFIG_TRACE_EARLY
/**
 * trace_early_init() - initialize the tracing system for early tracing
 *
 * Return:	0 if ok, -ENOSPC if not enough memory is available
 */
int notrace trace_early_init(void)
{
	int func_count = get_func_count();
	size_t buff_size = CONFIG_TRACE_EARLY_SIZE;
	size_t needed;

	if (func_count < 0)
		return func_count;
	/* We can ignore additional calls to this function */
	if (trace_enabled)
		return 0;

	hdr = map_sysmem(CONFIG_TRACE_EARLY_ADDR, CONFIG_TRACE_EARLY_SIZE);
	needed = sizeof(*hdr) + func_count * sizeof(uintptr_t);
	if (needed > buff_size) {
		printf("trace: buffer size is %zx bytes, at least %zx needed\n",
		       buff_size, needed);
		return -ENOSPC;
	}

	memset(hdr, '\0', needed);
	hdr->call_accum = (uintptr_t *)(hdr + 1);
	hdr->func_count = func_count;
	hdr->min_depth = INT_MAX;

	/* Use any remaining space for the timed function trace */
	hdr->ftrace = (struct trace_call *)((char *)hdr + needed);
	hdr->ftrace_size = (buff_size - needed) / sizeof(*hdr->ftrace);
	hdr->depth_limit = CONFIG_TRACE_EARLY_CALL_DEPTH_LIMIT;
	printf("trace: early enable at %08x\n", CONFIG_TRACE_EARLY_ADDR);

	trace_enabled = 1;

	return 0;
}
#endif
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
b2e16a85 SG	2	/*
b2e16a85 SG	3	* Copyright (c) 2012 The Chromium OS Authors.
b2e16a85 SG	4	*/
b2e16a85 SG	5
0eb25b61	6	#include <mapmem.h>
1045315d	7	#include <time.h>
b2e16a85	8	#include <trace.h>
467382ca	9	#include <linux/errno.h>
401d1c4f	10	#include <asm/global_data.h>
b2e16a85 SG	11	#include <asm/io.h>
	12	#include <asm/sections.h>
	13
	14	DECLARE_GLOBAL_DATA_PTR;
	15
236f2ec4 MB	16	static char trace_enabled __section(".data");
236f2ec4 MB	17	static char trace_inited __section(".data");
b2e16a85 SG	18
	19	/* The header block at the start of the trace memory area */
	20	struct trace_hdr {
	21	int func_count; /* Total number of function call sites */
	22	u64 call_count; /* Total number of tracked function calls */
	23	u64 untracked_count; /* Total number of untracked function calls */
	24	int funcs_used; /* Total number of functions used */
	25
	26	/*
	27	* Call count for each function. This is indexed by the word offset
	28	* of the function from gd->relocaddr
	29	*/
	30	uintptr_t *call_accum;
	31
	32	/* Function trace list */
	33	struct trace_call ftrace; / The function call records */
	34	ulong ftrace_size; /* Num. of ftrace records we have space for */
	35	ulong ftrace_count; /* Num. of ftrace records written */
	36	ulong ftrace_too_deep_count; /* Functions that were too deep */
	37
daca66d5 SG	38	int depth; /* Depth of function calls */
	39	int depth_limit; /* Depth limit to trace to */
	40	int max_depth; /* Maximum depth seen so far */
	41	int min_depth; /* Minimum depth seen so far */
852d4dbd	42	bool trace_locked; /* Used to detect recursive tracing */
b2e16a85 SG	43	};
b2e16a85 SG	44
bebc1410 SG	45	/* Pointer to start of trace buffer */
bebc1410 SG	46	static struct trace_hdr *hdr __section(".data");
b2e16a85 SG	47
	48	static inline uintptr_t __attribute__((no_instrument_function))
	49	func_ptr_to_num(void *func_ptr)
	50	{
	51	uintptr_t offset = (uintptr_t)func_ptr;
	52
	53	#ifdef CONFIG_SANDBOX
ccea96f4	54	offset -= (uintptr_t)_init;
b2e16a85 SG	55	#else
	56	if (gd->flags & GD_FLG_RELOC)
	57	offset -= gd->relocaddr;
	58	else
98463903	59	offset -= CONFIG_TEXT_BASE;
b2e16a85 SG	60	#endif
	61	return offset / FUNC_SITE_SIZE;
	62	}
	63
d3d6afae	64	#if defined(CONFIG_EFI_LOADER) && (defined(CONFIG_ARM) \|\| defined(CONFIG_RISCV))
a2fa38da HS	65
	66	/**
	67	* trace_gd - the value of the gd register
	68	*/
7f642cb2	69	static volatile gd_t *trace_gd;
a2fa38da HS	70
	71	/**
	72	* trace_save_gd() - save the value of the gd register
	73	*/
33c60a38	74	static void notrace trace_save_gd(void)
a2fa38da HS	75	{
	76	trace_gd = gd;
	77	}
	78
	79	/**
	80	* trace_swap_gd() - swap between U-Boot and application gd register value
	81	*
	82	* An UEFI application may change the value of the register that gd lives in.
	83	* But some of our functions like get_ticks() access this register. So we
	84	* have to set the gd register to the U-Boot value when entering a trace
	85	* point and set it back to the application value when exiting the trace point.
	86	*/
33c60a38	87	static void notrace trace_swap_gd(void)
a2fa38da	88	{
7f642cb2	89	volatile gd_t *temp_gd = trace_gd;
a2fa38da HS	90
a2fa38da HS	91	trace_gd = gd;
7f642cb2	92	set_gd(temp_gd);
a2fa38da HS	93	}
	94
	95	#else
	96
33c60a38	97	static void notrace trace_save_gd(void)
a2fa38da HS	98	{
	99	}
	100
33c60a38	101	static void notrace trace_swap_gd(void)
a2fa38da HS	102	{
	103	}
	104
	105	#endif
	106
33c60a38	107	static void notrace add_ftrace(void func_ptr, void caller, ulong flags)
b2e16a85 SG	108	{
	109	if (hdr->depth > hdr->depth_limit) {
	110	hdr->ftrace_too_deep_count++;
	111	return;
	112	}
	113	if (hdr->ftrace_count < hdr->ftrace_size) {
	114	struct trace_call *rec = &hdr->ftrace[hdr->ftrace_count];
	115
	116	rec->func = func_ptr_to_num(func_ptr);
	117	rec->caller = func_ptr_to_num(caller);
	118	rec->flags = flags \| (timer_get_us() & FUNCF_TIMESTAMP_MASK);
	119	}
	120	hdr->ftrace_count++;
	121	}
	122
b2e16a85	123	/**
e605ab84	124	* __cyg_profile_func_enter() - record function entry
b2e16a85 SG	125	*
	126	* We add to our tally for this function and add to the list of called
	127	* functions.
	128	*
e605ab84 HS	129	* @func_ptr: pointer to function being entered
e605ab84 HS	130	* @caller: pointer to function which called this function
b2e16a85	131	*/
33c60a38	132	void notrace __cyg_profile_func_enter(void func_ptr, void caller)
b2e16a85 SG	133	{
	134	if (trace_enabled) {
	135	int func;
	136
852d4dbd SG	137	if (hdr->trace_locked) {
	138	trace_enabled = 0;
	139	puts("trace: recursion detected, disabling\n");
	140	hdr->trace_locked = false;
	141	return;
	142	}
	143
	144	hdr->trace_locked = true;
a2fa38da	145	trace_swap_gd();
b2e16a85 SG	146	add_ftrace(func_ptr, caller, FUNCF_ENTRY);
	147	func = func_ptr_to_num(func_ptr);
	148	if (func < hdr->func_count) {
	149	hdr->call_accum[func]++;
	150	hdr->call_count++;
	151	} else {
	152	hdr->untracked_count++;
	153	}
	154	hdr->depth++;
daca66d5	155	if (hdr->depth > hdr->max_depth)
b2e16a85	156	hdr->max_depth = hdr->depth;
a2fa38da	157	trace_swap_gd();
852d4dbd	158	hdr->trace_locked = false;
b2e16a85 SG	159	}
	160	}
	161
	162	/**
e605ab84	163	* __cyg_profile_func_exit() - record function exit
b2e16a85	164	*
e605ab84 HS	165	* @func_ptr: pointer to function being entered
e605ab84 HS	166	* @caller: pointer to function which called this function
b2e16a85	167	*/
33c60a38	168	void notrace __cyg_profile_func_exit(void func_ptr, void caller)
b2e16a85 SG	169	{
b2e16a85 SG	170	if (trace_enabled) {
a2fa38da	171	trace_swap_gd();
b2e16a85	172	hdr->depth--;
daca66d5 SG	173	add_ftrace(func_ptr, caller, FUNCF_EXIT);
	174	if (hdr->depth < hdr->min_depth)
	175	hdr->min_depth = hdr->depth;
a2fa38da	176	trace_swap_gd();
b2e16a85 SG	177	}
	178	}
	179
	180	/**
e605ab84	181	* trace_list_functions() - produce a list of called functions
b2e16a85 SG	182	*
	183	* The information is written into the supplied buffer - a header followed
	184	* by a list of function records.
	185	*
e605ab84 HS	186	* @buff: buffer to place list into
	187	* @buff_size: size of buffer
	188	* @needed: returns size of buffer needed, which may be
	189	* greater than buff_size if we ran out of space.
	190	* Return: 0 if ok, -ENOSPC if space was exhausted
b2e16a85	191	*/
2b7a3882	192	int trace_list_functions(void buff, size_t buff_size, size_t needed)
b2e16a85 SG	193	{
	194	struct trace_output_hdr *output_hdr = NULL;
	195	void end, ptr = buff;
2b7a3882 HS	196	size_t func;
2b7a3882 HS	197	size_t upto;
b2e16a85 SG	198
	199	end = buff ? buff + buff_size : NULL;
	200
	201	/* Place some header information */
	202	if (ptr + sizeof(struct trace_output_hdr) < end)
	203	output_hdr = ptr;
	204	ptr += sizeof(struct trace_output_hdr);
	205
	206	/* Add information about each function */
	207	for (func = upto = 0; func < hdr->func_count; func++) {
2b7a3882	208	size_t calls = hdr->call_accum[func];
b2e16a85 SG	209
	210	if (!calls)
	211	continue;
	212
	213	if (ptr + sizeof(struct trace_output_func) < end) {
	214	struct trace_output_func *stats = ptr;
	215
	216	stats->offset = func * FUNC_SITE_SIZE;
	217	stats->call_count = calls;
	218	upto++;
	219	}
	220	ptr += sizeof(struct trace_output_func);
	221	}
	222
	223	/* Update the header */
	224	if (output_hdr) {
	225	output_hdr->rec_count = upto;
	226	output_hdr->type = TRACE_CHUNK_FUNCS;
	227	}
	228
	229	/* Work out how must of the buffer we used */
	230	*needed = ptr - buff;
	231	if (ptr > end)
f564d096 SG	232	return -ENOSPC;
f564d096 SG	233
b2e16a85 SG	234	return 0;
	235	}
	236
e605ab84 HS	237	/**
	238	* trace_list_functions() - produce a list of function calls
	239	*
	240	* The information is written into the supplied buffer - a header followed
	241	* by a list of function records.
	242	*
	243	* @buff: buffer to place list into
	244	* @buff_size: size of buffer
	245	* @needed: returns size of buffer needed, which may be
	246	* greater than buff_size if we ran out of space.
	247	* Return: 0 if ok, -ENOSPC if space was exhausted
	248	*/
2b7a3882	249	int trace_list_calls(void buff, size_t buff_size, size_t needed)
b2e16a85 SG	250	{
	251	struct trace_output_hdr *output_hdr = NULL;
	252	void end, ptr = buff;
2b7a3882 HS	253	size_t rec, upto;
2b7a3882 HS	254	size_t count;
b2e16a85 SG	255
	256	end = buff ? buff + buff_size : NULL;
	257
	258	/* Place some header information */
	259	if (ptr + sizeof(struct trace_output_hdr) < end)
	260	output_hdr = ptr;
	261	ptr += sizeof(struct trace_output_hdr);
	262
	263	/* Add information about each call */
	264	count = hdr->ftrace_count;
	265	if (count > hdr->ftrace_size)
	266	count = hdr->ftrace_size;
	267	for (rec = upto = 0; rec < count; rec++) {
	268	if (ptr + sizeof(struct trace_call) < end) {
	269	struct trace_call *call = &hdr->ftrace[rec];
	270	struct trace_call *out = ptr;
	271
	272	out->func = call->func * FUNC_SITE_SIZE;
	273	out->caller = call->caller * FUNC_SITE_SIZE;
	274	out->flags = call->flags;
	275	upto++;
	276	}
	277	ptr += sizeof(struct trace_call);
	278	}
	279
	280	/* Update the header */
	281	if (output_hdr) {
d9044e53	282	memset(output_hdr, '\0', sizeof(*output_hdr));
b2e16a85 SG	283	output_hdr->rec_count = upto;
b2e16a85 SG	284	output_hdr->type = TRACE_CHUNK_CALLS;
d9044e53 SG	285	output_hdr->version = TRACE_VERSION;
d9044e53 SG	286	output_hdr->text_base = CONFIG_TEXT_BASE;
b2e16a85 SG	287	}
	288
	289	/* Work out how must of the buffer we used */
	290	*needed = ptr - buff;
	291	if (ptr > end)
f564d096 SG	292	return -ENOSPC;
f564d096 SG	293
b2e16a85 SG	294	return 0;
	295	}
	296
e605ab84 HS	297	/**
	298	* trace_print_stats() - print basic information about tracing
	299	*/
b2e16a85 SG	300	void trace_print_stats(void)
	301	{
	302	ulong count;
	303
	304	#ifndef FTRACE
	305	puts("Warning: make U-Boot with FTRACE to enable function instrumenting.\n");
	306	puts("You will likely get zeroed data here\n");
	307	#endif
	308	if (!trace_inited) {
	309	printf("Trace is disabled\n");
	310	return;
	311	}
	312	print_grouped_ull(hdr->func_count, 10);
	313	puts(" function sites\n");
	314	print_grouped_ull(hdr->call_count, 10);
	315	puts(" function calls\n");
	316	print_grouped_ull(hdr->untracked_count, 10);
	317	puts(" untracked function calls\n");
	318	count = min(hdr->ftrace_count, hdr->ftrace_size);
	319	print_grouped_ull(count, 10);
	320	puts(" traced function calls");
	321	if (hdr->ftrace_count > hdr->ftrace_size) {
	322	printf(" (%lu dropped due to overflow)",
	323	hdr->ftrace_count - hdr->ftrace_size);
	324	}
daca66d5 SG	325
	326	/* Add in minimum depth since the trace did not start at top level */
	327	printf("\n%15d maximum observed call depth\n",
	328	hdr->max_depth - hdr->min_depth);
b2e16a85 SG	329	printf("%15d call depth limit\n", hdr->depth_limit);
	330	print_grouped_ull(hdr->ftrace_too_deep_count, 10);
	331	puts(" calls not traced due to depth\n");
9dd665ad SG	332	print_grouped_ull(hdr->ftrace_size, 10);
	333	puts(" max function calls\n");
	334	printf("\ntrace buffer %lx call records %lx\n",
	335	(ulong)map_to_sysmem(hdr), (ulong)map_to_sysmem(hdr->ftrace));
b2e16a85 SG	336	}
b2e16a85 SG	337
33c60a38	338	void notrace trace_set_enabled(int enabled)
b2e16a85 SG	339	{
	340	trace_enabled = enabled != 0;
	341	}
	342
c3d91812 SG	343	static int get_func_count(void)
	344	{
	345	/* Detect no support for mon_len since this means tracing cannot work */
	346	if (IS_ENABLED(CONFIG_SANDBOX) && !gd->mon_len) {
	347	puts("Tracing is not supported on this board\n");
	348	return -ENOTSUPP;
	349	}
	350
	351	return gd->mon_len / FUNC_SITE_SIZE;
	352	}
	353
b2e16a85	354	/**
e605ab84	355	* trace_init() - initialize the tracing system and enable it
b2e16a85	356	*
e605ab84 HS	357	* @buff: Pointer to trace buffer
	358	* @buff_size: Size of trace buffer
	359	* Return: 0 if ok
b2e16a85	360	*/
33c60a38	361	int notrace trace_init(void *buff, size_t buff_size)
b2e16a85	362	{
c3d91812	363	int func_count = get_func_count();
b2e16a85 SG	364	size_t needed;
	365	int was_disabled = !trace_enabled;
	366
c3d91812 SG	367	if (func_count < 0)
c3d91812 SG	368	return func_count;
a2fa38da HS	369	trace_save_gd();
a2fa38da HS	370
b2e16a85 SG	371	if (!was_disabled) {
b2e16a85 SG	372	#ifdef CONFIG_TRACE_EARLY
80f91558	373	ulong used, count;
b2e16a85	374	char *end;
b2e16a85 SG	375
	376	/*
	377	* Copy over the early trace data if we have it. Disable
	378	* tracing while we are doing this.
	379	*/
	380	trace_enabled = 0;
	381	hdr = map_sysmem(CONFIG_TRACE_EARLY_ADDR,
	382	CONFIG_TRACE_EARLY_SIZE);
80f91558 SG	383	count = min(hdr->ftrace_count, hdr->ftrace_size);
80f91558 SG	384	end = (char *)&hdr->ftrace[count];
b2e16a85 SG	385	used = end - (char *)hdr;
	386	printf("trace: copying %08lx bytes of early data from %x to %08lx\n",
	387	used, CONFIG_TRACE_EARLY_ADDR,
	388	(ulong)map_to_sysmem(buff));
80f91558 SG	389	printf("%lu traced function calls", count);
	390	if (hdr->ftrace_count > hdr->ftrace_size) {
	391	printf(" (%lu dropped due to overflow)",
	392	hdr->ftrace_count - hdr->ftrace_size);
	393	hdr->ftrace_count = hdr->ftrace_size;
	394	}
	395	puts("\n");
b2e16a85 SG	396	memcpy(buff, hdr, used);
	397	#else
	398	puts("trace: already enabled\n");
f564d096	399	return -EALREADY;
b2e16a85 SG	400	#endif
	401	}
	402	hdr = (struct trace_hdr *)buff;
	403	needed = sizeof(hdr) + func_count sizeof(uintptr_t);
	404	if (needed > buff_size) {
9dd665ad	405	printf("trace: buffer size %zx bytes: at least %zx needed\n",
b2e16a85	406	buff_size, needed);
f564d096	407	return -ENOSPC;
b2e16a85 SG	408	}
b2e16a85 SG	409
daca66d5	410	if (was_disabled) {
b2e16a85	411	memset(hdr, '\0', needed);
daca66d5 SG	412	hdr->min_depth = INT_MAX;
daca66d5 SG	413	}
b2e16a85 SG	414	hdr->func_count = func_count;
	415	hdr->call_accum = (uintptr_t *)(hdr + 1);
	416
	417	/* Use any remaining space for the timed function trace */
	418	hdr->ftrace = (struct trace_call *)(buff + needed);
	419	hdr->ftrace_size = (buff_size - needed) / sizeof(*hdr->ftrace);
d9044e53	420	hdr->depth_limit = CONFIG_TRACE_CALL_DEPTH_LIMIT;
b2e16a85 SG	421
b2e16a85 SG	422	puts("trace: enabled\n");
b2e16a85 SG	423	trace_enabled = 1;
b2e16a85 SG	424	trace_inited = 1;
f564d096	425
b2e16a85 SG	426	return 0;
	427	}
	428
	429	#ifdef CONFIG_TRACE_EARLY
e605ab84 HS	430	/**
	431	* trace_early_init() - initialize the tracing system for early tracing
	432	*
	433	* Return: 0 if ok, -ENOSPC if not enough memory is available
	434	*/
33c60a38	435	int notrace trace_early_init(void)
b2e16a85	436	{
c3d91812	437	int func_count = get_func_count();
b2e16a85 SG	438	size_t buff_size = CONFIG_TRACE_EARLY_SIZE;
	439	size_t needed;
	440
c3d91812 SG	441	if (func_count < 0)
c3d91812 SG	442	return func_count;
b2e16a85 SG	443	/* We can ignore additional calls to this function */
	444	if (trace_enabled)
	445	return 0;
	446
	447	hdr = map_sysmem(CONFIG_TRACE_EARLY_ADDR, CONFIG_TRACE_EARLY_SIZE);
	448	needed = sizeof(hdr) + func_count sizeof(uintptr_t);
	449	if (needed > buff_size) {
9dd665ad	450	printf("trace: buffer size is %zx bytes, at least %zx needed\n",
b2e16a85	451	buff_size, needed);
f564d096	452	return -ENOSPC;
b2e16a85 SG	453	}
	454
	455	memset(hdr, '\0', needed);
	456	hdr->call_accum = (uintptr_t *)(hdr + 1);
	457	hdr->func_count = func_count;
daca66d5	458	hdr->min_depth = INT_MAX;
b2e16a85 SG	459
	460	/* Use any remaining space for the timed function trace */
	461	hdr->ftrace = (struct trace_call )((char )hdr + needed);
	462	hdr->ftrace_size = (buff_size - needed) / sizeof(*hdr->ftrace);
da0fb5fd	463	hdr->depth_limit = CONFIG_TRACE_EARLY_CALL_DEPTH_LIMIT;
b2e16a85 SG	464	printf("trace: early enable at %08x\n", CONFIG_TRACE_EARLY_ADDR);
	465
	466	trace_enabled = 1;
f564d096	467
b2e16a85 SG	468	return 0;
	469	}
	470	#endif