Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 1 | /* |
| 2 | * This file defines the trace event structures that go into the ring |
| 3 | * buffer directly. They are created via macros so that changes for them |
| 4 | * appear in the format file. Using macros will automate this process. |
| 5 | * |
| 6 | * The macro used to create a ftrace data structure is: |
| 7 | * |
| 8 | * FTRACE_ENTRY( name, struct_name, id, structure, print ) |
| 9 | * |
| 10 | * @name: the name used the event name, as well as the name of |
| 11 | * the directory that holds the format file. |
| 12 | * |
| 13 | * @struct_name: the name of the structure that is created. |
| 14 | * |
| 15 | * @id: The event identifier that is used to detect what event |
| 16 | * this is from the ring buffer. |
| 17 | * |
| 18 | * @structure: the structure layout |
| 19 | * |
| 20 | * - __field( type, item ) |
| 21 | * This is equivalent to declaring |
| 22 | * type item; |
| 23 | * in the structure. |
| 24 | * - __array( type, item, size ) |
| 25 | * This is equivalent to declaring |
| 26 | * type item[size]; |
| 27 | * in the structure. |
| 28 | * |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 29 | * * for structures within structures, the format of the internal |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 30 | * structure is laid out. This allows the internal structure |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 31 | * to be deciphered for the format file. Although these macros |
| 32 | * may become out of sync with the internal structure, they |
| 33 | * will create a compile error if it happens. Since the |
| 34 | * internel structures are just tracing helpers, this is not |
| 35 | * an issue. |
| 36 | * |
| 37 | * When an internal structure is used, it should use: |
| 38 | * |
| 39 | * __field_struct( type, item ) |
| 40 | * |
| 41 | * instead of __field. This will prevent it from being shown in |
| 42 | * the output file. The fields in the structure should use. |
| 43 | * |
| 44 | * __field_desc( type, container, item ) |
| 45 | * __array_desc( type, container, item, len ) |
| 46 | * |
| 47 | * type, item and len are the same as __field and __array, but |
| 48 | * container is added. This is the name of the item in |
| 49 | * __field_struct that this is describing. |
| 50 | * |
| 51 | * |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 52 | * @print: the print format shown to users in the format file. |
| 53 | */ |
| 54 | |
| 55 | /* |
Uwe Kleine-König | b595076 | 2010-11-01 15:38:34 -0400 | [diff] [blame] | 56 | * Function trace entry - function address and parent function address: |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 57 | */ |
| 58 | FTRACE_ENTRY(function, ftrace_entry, |
| 59 | |
| 60 | TRACE_FN, |
| 61 | |
| 62 | F_STRUCT( |
| 63 | __field( unsigned long, ip ) |
| 64 | __field( unsigned long, parent_ip ) |
| 65 | ), |
| 66 | |
| 67 | F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip) |
| 68 | ); |
| 69 | |
| 70 | /* Function call entry */ |
| 71 | FTRACE_ENTRY(funcgraph_entry, ftrace_graph_ent_entry, |
| 72 | |
| 73 | TRACE_GRAPH_ENT, |
| 74 | |
| 75 | F_STRUCT( |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 76 | __field_struct( struct ftrace_graph_ent, graph_ent ) |
| 77 | __field_desc( unsigned long, graph_ent, func ) |
| 78 | __field_desc( int, graph_ent, depth ) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 79 | ), |
| 80 | |
Li Zefan | c16de8f | 2009-09-14 15:51:39 +0800 | [diff] [blame] | 81 | F_printk("--> %lx (%d)", __entry->func, __entry->depth) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 82 | ); |
| 83 | |
| 84 | /* Function return entry */ |
| 85 | FTRACE_ENTRY(funcgraph_exit, ftrace_graph_ret_entry, |
| 86 | |
| 87 | TRACE_GRAPH_RET, |
| 88 | |
| 89 | F_STRUCT( |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 90 | __field_struct( struct ftrace_graph_ret, ret ) |
| 91 | __field_desc( unsigned long, ret, func ) |
| 92 | __field_desc( unsigned long long, ret, calltime) |
| 93 | __field_desc( unsigned long long, ret, rettime ) |
| 94 | __field_desc( unsigned long, ret, overrun ) |
| 95 | __field_desc( int, ret, depth ) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 96 | ), |
| 97 | |
| 98 | F_printk("<-- %lx (%d) (start: %llx end: %llx) over: %d", |
| 99 | __entry->func, __entry->depth, |
Li Zefan | c16de8f | 2009-09-14 15:51:39 +0800 | [diff] [blame] | 100 | __entry->calltime, __entry->rettime, |
| 101 | __entry->depth) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 102 | ); |
| 103 | |
| 104 | /* |
| 105 | * Context switch trace entry - which task (and prio) we switched from/to: |
| 106 | * |
| 107 | * This is used for both wakeup and context switches. We only want |
| 108 | * to create one structure, but we need two outputs for it. |
| 109 | */ |
| 110 | #define FTRACE_CTX_FIELDS \ |
| 111 | __field( unsigned int, prev_pid ) \ |
David Sharp | 140e4f2 | 2010-12-03 16:13:19 -0800 | [diff] [blame] | 112 | __field( unsigned int, next_pid ) \ |
| 113 | __field( unsigned int, next_cpu ) \ |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 114 | __field( unsigned char, prev_prio ) \ |
| 115 | __field( unsigned char, prev_state ) \ |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 116 | __field( unsigned char, next_prio ) \ |
David Sharp | 140e4f2 | 2010-12-03 16:13:19 -0800 | [diff] [blame] | 117 | __field( unsigned char, next_state ) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 118 | |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 119 | FTRACE_ENTRY(context_switch, ctx_switch_entry, |
| 120 | |
| 121 | TRACE_CTX, |
| 122 | |
| 123 | F_STRUCT( |
| 124 | FTRACE_CTX_FIELDS |
| 125 | ), |
| 126 | |
Li Zefan | c16de8f | 2009-09-14 15:51:39 +0800 | [diff] [blame] | 127 | F_printk("%u:%u:%u ==> %u:%u:%u [%03u]", |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 128 | __entry->prev_pid, __entry->prev_prio, __entry->prev_state, |
| 129 | __entry->next_pid, __entry->next_prio, __entry->next_state, |
| 130 | __entry->next_cpu |
| 131 | ) |
| 132 | ); |
| 133 | |
| 134 | /* |
| 135 | * FTRACE_ENTRY_DUP only creates the format file, it will not |
| 136 | * create another structure. |
| 137 | */ |
| 138 | FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry, |
| 139 | |
| 140 | TRACE_WAKE, |
| 141 | |
| 142 | F_STRUCT( |
| 143 | FTRACE_CTX_FIELDS |
| 144 | ), |
| 145 | |
| 146 | F_printk("%u:%u:%u ==+ %u:%u:%u [%03u]", |
| 147 | __entry->prev_pid, __entry->prev_prio, __entry->prev_state, |
| 148 | __entry->next_pid, __entry->next_prio, __entry->next_state, |
| 149 | __entry->next_cpu |
| 150 | ) |
| 151 | ); |
| 152 | |
| 153 | /* |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 154 | * Stack-trace entry: |
| 155 | */ |
| 156 | |
| 157 | #define FTRACE_STACK_ENTRIES 8 |
| 158 | |
| 159 | FTRACE_ENTRY(kernel_stack, stack_entry, |
| 160 | |
| 161 | TRACE_STACK, |
| 162 | |
| 163 | F_STRUCT( |
Steven Rostedt | 4a9bd3f | 2011-07-14 16:36:53 -0400 | [diff] [blame] | 164 | __field( int, size ) |
| 165 | __dynamic_array(unsigned long, caller ) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 166 | ), |
| 167 | |
| 168 | F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n" |
| 169 | "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n", |
| 170 | __entry->caller[0], __entry->caller[1], __entry->caller[2], |
| 171 | __entry->caller[3], __entry->caller[4], __entry->caller[5], |
| 172 | __entry->caller[6], __entry->caller[7]) |
| 173 | ); |
| 174 | |
| 175 | FTRACE_ENTRY(user_stack, userstack_entry, |
| 176 | |
| 177 | TRACE_USER_STACK, |
| 178 | |
| 179 | F_STRUCT( |
| 180 | __field( unsigned int, tgid ) |
| 181 | __array( unsigned long, caller, FTRACE_STACK_ENTRIES ) |
| 182 | ), |
| 183 | |
| 184 | F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n" |
| 185 | "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n", |
| 186 | __entry->caller[0], __entry->caller[1], __entry->caller[2], |
| 187 | __entry->caller[3], __entry->caller[4], __entry->caller[5], |
| 188 | __entry->caller[6], __entry->caller[7]) |
| 189 | ); |
| 190 | |
| 191 | /* |
| 192 | * trace_printk entry: |
| 193 | */ |
| 194 | FTRACE_ENTRY(bprint, bprint_entry, |
| 195 | |
| 196 | TRACE_BPRINT, |
| 197 | |
| 198 | F_STRUCT( |
| 199 | __field( unsigned long, ip ) |
| 200 | __field( const char *, fmt ) |
| 201 | __dynamic_array( u32, buf ) |
| 202 | ), |
| 203 | |
| 204 | F_printk("%08lx fmt:%p", |
| 205 | __entry->ip, __entry->fmt) |
| 206 | ); |
| 207 | |
| 208 | FTRACE_ENTRY(print, print_entry, |
| 209 | |
| 210 | TRACE_PRINT, |
| 211 | |
| 212 | F_STRUCT( |
| 213 | __field( unsigned long, ip ) |
| 214 | __dynamic_array( char, buf ) |
| 215 | ), |
| 216 | |
| 217 | F_printk("%08lx %s", |
| 218 | __entry->ip, __entry->buf) |
| 219 | ); |
| 220 | |
| 221 | FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw, |
| 222 | |
| 223 | TRACE_MMIO_RW, |
| 224 | |
| 225 | F_STRUCT( |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 226 | __field_struct( struct mmiotrace_rw, rw ) |
| 227 | __field_desc( resource_size_t, rw, phys ) |
| 228 | __field_desc( unsigned long, rw, value ) |
| 229 | __field_desc( unsigned long, rw, pc ) |
| 230 | __field_desc( int, rw, map_id ) |
| 231 | __field_desc( unsigned char, rw, opcode ) |
| 232 | __field_desc( unsigned char, rw, width ) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 233 | ), |
| 234 | |
Li Zefan | c16de8f | 2009-09-14 15:51:39 +0800 | [diff] [blame] | 235 | F_printk("%lx %lx %lx %d %x %x", |
| 236 | (unsigned long)__entry->phys, __entry->value, __entry->pc, |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 237 | __entry->map_id, __entry->opcode, __entry->width) |
| 238 | ); |
| 239 | |
| 240 | FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map, |
| 241 | |
| 242 | TRACE_MMIO_MAP, |
| 243 | |
| 244 | F_STRUCT( |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 245 | __field_struct( struct mmiotrace_map, map ) |
| 246 | __field_desc( resource_size_t, map, phys ) |
| 247 | __field_desc( unsigned long, map, virt ) |
| 248 | __field_desc( unsigned long, map, len ) |
| 249 | __field_desc( int, map, map_id ) |
| 250 | __field_desc( unsigned char, map, opcode ) |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 251 | ), |
| 252 | |
Li Zefan | c16de8f | 2009-09-14 15:51:39 +0800 | [diff] [blame] | 253 | F_printk("%lx %lx %lx %d %x", |
| 254 | (unsigned long)__entry->phys, __entry->virt, __entry->len, |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 255 | __entry->map_id, __entry->opcode) |
| 256 | ); |
| 257 | |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 258 | |
| 259 | #define TRACE_FUNC_SIZE 30 |
| 260 | #define TRACE_FILE_SIZE 20 |
| 261 | |
| 262 | FTRACE_ENTRY(branch, trace_branch, |
| 263 | |
| 264 | TRACE_BRANCH, |
| 265 | |
| 266 | F_STRUCT( |
| 267 | __field( unsigned int, line ) |
| 268 | __array( char, func, TRACE_FUNC_SIZE+1 ) |
| 269 | __array( char, file, TRACE_FILE_SIZE+1 ) |
| 270 | __field( char, correct ) |
| 271 | ), |
| 272 | |
| 273 | F_printk("%u:%s:%s (%u)", |
| 274 | __entry->line, |
| 275 | __entry->func, __entry->file, __entry->correct) |
| 276 | ); |
| 277 | |