1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 /* 3 * Copyright (c) 2012 The Chromium OS Authors. 4 */ 5 6 #ifndef __TRACE_H 7 #define __TRACE_H 8 9 enum { 10 /* 11 * This affects the granularity of our trace. We can bin function 12 * entry points into groups on the basis that functions typically 13 * have a minimum size, so entry points can't appear any closer 14 * than this to each other. 15 * 16 * The value here assumes a minimum instruction size of 4 bytes, 17 * or that instructions are 2 bytes but there are at least 2 of 18 * them in every function. 19 * 20 * Increasing this value reduces the number of functions we can 21 * resolve, but reduces the size of the uintptr_t array used for 22 * our function list, which is the length of the code divided by 23 * this value. 24 */ 25 FUNC_SITE_SIZE = 4, /* distance between function sites */ 26 }; 27 28 enum trace_chunk_type { 29 TRACE_CHUNK_FUNCS, 30 TRACE_CHUNK_CALLS, 31 }; 32 33 /* A trace record for a function, as written to the profile output file */ 34 struct trace_output_func { 35 uint32_t offset; /* Function offset into code */ 36 uint32_t call_count; /* Number of times called */ 37 }; 38 39 /* A header at the start of the trace output buffer */ 40 struct trace_output_hdr { 41 enum trace_chunk_type type; /* Record type */ 42 size_t rec_count; /* Number of records */ 43 }; 44 45 /* Print statistics about traced function calls */ 46 void trace_print_stats(void); 47 48 /** 49 * Dump a list of functions and call counts into a buffer 50 * 51 * Each record in the buffer is a struct trace_func_stats. The 'needed' 52 * parameter returns the number of bytes needed to complete the operation, 53 * which may be more than buff_size if your buffer is too small. 54 * 55 * @param buff Buffer in which to place data, or NULL to count size 56 * @param buff_size Size of buffer 57 * @param needed Returns number of bytes used / needed 58 * @return 0 if ok, -1 on error (buffer exhausted) 59 */ 60 int trace_list_functions(void *buff, size_t buff_size, size_t *needed); 61 62 /* Flags for ftrace_record */ 63 enum ftrace_flags { 64 FUNCF_EXIT = 0UL << 30, 65 FUNCF_ENTRY = 1UL << 30, 66 FUNCF_TEXTBASE = 2UL << 30, 67 68 FUNCF_TIMESTAMP_MASK = 0x3fffffff, 69 }; 70 71 #define TRACE_CALL_TYPE(call) ((call)->flags & 0xc0000000UL) 72 73 /* Information about a single function entry/exit */ 74 struct trace_call { 75 uint32_t func; /* Function offset */ 76 uint32_t caller; /* Caller function offset */ 77 uint32_t flags; /* Flags and timestamp */ 78 }; 79 80 int trace_list_calls(void *buff, size_t buff_size, size_t *needed); 81 82 /** 83 * Turn function tracing on and off 84 * 85 * Don't enable trace if it has not been initialised. 86 * 87 * @param enabled 1 to enable trace, 0 to disable 88 */ 89 void trace_set_enabled(int enabled); 90 91 int trace_early_init(void); 92 93 /** 94 * Init the trace system 95 * 96 * This should be called after relocation with a suitably large buffer 97 * (typically as large as the U-Boot text area) 98 * 99 * @param buff Pointer to trace buffer 100 * @param buff_size Size of trace buffer 101 */ 102 int trace_init(void *buff, size_t buff_size); 103 104 #endif 105