1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2014, Michael Ellerman, IBM Corp. 4 */ 5 6 #include <errno.h> 7 #include <stdio.h> 8 #include <stdlib.h> 9 #include <string.h> 10 #include <sys/mman.h> 11 12 #include "trace.h" 13 14 15 struct trace_buffer *trace_buffer_allocate(u64 size) 16 { 17 struct trace_buffer *tb; 18 19 if (size < sizeof(*tb)) { 20 fprintf(stderr, "Error: trace buffer too small\n"); 21 return NULL; 22 } 23 24 tb = mmap(NULL, size, PROT_READ | PROT_WRITE, 25 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); 26 if (tb == MAP_FAILED) { 27 perror("mmap"); 28 return NULL; 29 } 30 31 tb->size = size; 32 tb->tail = tb->data; 33 tb->overflow = false; 34 35 return tb; 36 } 37 38 static bool trace_check_bounds(struct trace_buffer *tb, void *p) 39 { 40 return p < ((void *)tb + tb->size); 41 } 42 43 static bool trace_check_alloc(struct trace_buffer *tb, void *p) 44 { 45 /* 46 * If we ever overflowed don't allow any more input. This prevents us 47 * from dropping a large item and then later logging a small one. The 48 * buffer should just stop when overflow happened, not be patchy. If 49 * you're overflowing, make your buffer bigger. 50 */ 51 if (tb->overflow) 52 return false; 53 54 if (!trace_check_bounds(tb, p)) { 55 tb->overflow = true; 56 return false; 57 } 58 59 return true; 60 } 61 62 static void *trace_alloc(struct trace_buffer *tb, int bytes) 63 { 64 void *p, *newtail; 65 66 p = tb->tail; 67 newtail = tb->tail + bytes; 68 if (!trace_check_alloc(tb, newtail)) 69 return NULL; 70 71 tb->tail = newtail; 72 73 return p; 74 } 75 76 static struct trace_entry *trace_alloc_entry(struct trace_buffer *tb, int payload_size) 77 { 78 struct trace_entry *e; 79 80 e = trace_alloc(tb, sizeof(*e) + payload_size); 81 if (e) 82 e->length = payload_size; 83 84 return e; 85 } 86 87 int trace_log_reg(struct trace_buffer *tb, u64 reg, u64 value) 88 { 89 struct trace_entry *e; 90 u64 *p; 91 92 e = trace_alloc_entry(tb, sizeof(reg) + sizeof(value)); 93 if (!e) 94 return -ENOSPC; 95 96 e->type = TRACE_TYPE_REG; 97 p = (u64 *)e->data; 98 *p++ = reg; 99 *p++ = value; 100 101 return 0; 102 } 103 104 int trace_log_counter(struct trace_buffer *tb, u64 value) 105 { 106 struct trace_entry *e; 107 u64 *p; 108 109 e = trace_alloc_entry(tb, sizeof(value)); 110 if (!e) 111 return -ENOSPC; 112 113 e->type = TRACE_TYPE_COUNTER; 114 p = (u64 *)e->data; 115 *p++ = value; 116 117 return 0; 118 } 119 120 int trace_log_string(struct trace_buffer *tb, char *str) 121 { 122 struct trace_entry *e; 123 char *p; 124 int len; 125 126 len = strlen(str); 127 128 /* We NULL terminate to make printing easier */ 129 e = trace_alloc_entry(tb, len + 1); 130 if (!e) 131 return -ENOSPC; 132 133 e->type = TRACE_TYPE_STRING; 134 p = (char *)e->data; 135 memcpy(p, str, len); 136 p += len; 137 *p = '\0'; 138 139 return 0; 140 } 141 142 int trace_log_indent(struct trace_buffer *tb) 143 { 144 struct trace_entry *e; 145 146 e = trace_alloc_entry(tb, 0); 147 if (!e) 148 return -ENOSPC; 149 150 e->type = TRACE_TYPE_INDENT; 151 152 return 0; 153 } 154 155 int trace_log_outdent(struct trace_buffer *tb) 156 { 157 struct trace_entry *e; 158 159 e = trace_alloc_entry(tb, 0); 160 if (!e) 161 return -ENOSPC; 162 163 e->type = TRACE_TYPE_OUTDENT; 164 165 return 0; 166 } 167 168 static void trace_print_header(int seq, int prefix) 169 { 170 printf("%*s[%d]: ", prefix, "", seq); 171 } 172 173 static char *trace_decode_reg(int reg) 174 { 175 switch (reg) { 176 case 769: return "SPRN_MMCR2"; break; 177 case 770: return "SPRN_MMCRA"; break; 178 case 779: return "SPRN_MMCR0"; break; 179 case 804: return "SPRN_EBBHR"; break; 180 case 805: return "SPRN_EBBRR"; break; 181 case 806: return "SPRN_BESCR"; break; 182 case 800: return "SPRN_BESCRS"; break; 183 case 801: return "SPRN_BESCRSU"; break; 184 case 802: return "SPRN_BESCRR"; break; 185 case 803: return "SPRN_BESCRRU"; break; 186 case 771: return "SPRN_PMC1"; break; 187 case 772: return "SPRN_PMC2"; break; 188 case 773: return "SPRN_PMC3"; break; 189 case 774: return "SPRN_PMC4"; break; 190 case 775: return "SPRN_PMC5"; break; 191 case 776: return "SPRN_PMC6"; break; 192 case 780: return "SPRN_SIAR"; break; 193 case 781: return "SPRN_SDAR"; break; 194 case 768: return "SPRN_SIER"; break; 195 } 196 197 return NULL; 198 } 199 200 static void trace_print_reg(struct trace_entry *e) 201 { 202 u64 *p, *reg, *value; 203 char *name; 204 205 p = (u64 *)e->data; 206 reg = p++; 207 value = p; 208 209 name = trace_decode_reg(*reg); 210 if (name) 211 printf("register %-10s = 0x%016llx\n", name, *value); 212 else 213 printf("register %lld = 0x%016llx\n", *reg, *value); 214 } 215 216 static void trace_print_counter(struct trace_entry *e) 217 { 218 u64 *value; 219 220 value = (u64 *)e->data; 221 printf("counter = %lld\n", *value); 222 } 223 224 static void trace_print_string(struct trace_entry *e) 225 { 226 char *str; 227 228 str = (char *)e->data; 229 puts(str); 230 } 231 232 #define BASE_PREFIX 2 233 #define PREFIX_DELTA 8 234 235 static void trace_print_entry(struct trace_entry *e, int seq, int *prefix) 236 { 237 switch (e->type) { 238 case TRACE_TYPE_REG: 239 trace_print_header(seq, *prefix); 240 trace_print_reg(e); 241 break; 242 case TRACE_TYPE_COUNTER: 243 trace_print_header(seq, *prefix); 244 trace_print_counter(e); 245 break; 246 case TRACE_TYPE_STRING: 247 trace_print_header(seq, *prefix); 248 trace_print_string(e); 249 break; 250 case TRACE_TYPE_INDENT: 251 trace_print_header(seq, *prefix); 252 puts("{"); 253 *prefix += PREFIX_DELTA; 254 break; 255 case TRACE_TYPE_OUTDENT: 256 *prefix -= PREFIX_DELTA; 257 if (*prefix < BASE_PREFIX) 258 *prefix = BASE_PREFIX; 259 trace_print_header(seq, *prefix); 260 puts("}"); 261 break; 262 default: 263 trace_print_header(seq, *prefix); 264 printf("entry @ %p type %d\n", e, e->type); 265 break; 266 } 267 } 268 269 void trace_buffer_print(struct trace_buffer *tb) 270 { 271 struct trace_entry *e; 272 int i, prefix; 273 void *p; 274 275 printf("Trace buffer dump:\n"); 276 printf(" address %p \n", tb); 277 printf(" tail %p\n", tb->tail); 278 printf(" size %llu\n", tb->size); 279 printf(" overflow %s\n", tb->overflow ? "TRUE" : "false"); 280 printf(" Content:\n"); 281 282 p = tb->data; 283 284 i = 0; 285 prefix = BASE_PREFIX; 286 287 while (trace_check_bounds(tb, p) && p < tb->tail) { 288 e = p; 289 290 trace_print_entry(e, i, &prefix); 291 292 i++; 293 p = (void *)e + sizeof(*e) + e->length; 294 } 295 } 296 297 void trace_print_location(struct trace_buffer *tb) 298 { 299 printf("Trace buffer 0x%llx bytes @ %p\n", tb->size, tb); 300 } 301