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