6db4831e98
Android 14
301 lines
5.6 KiB
C
301 lines
5.6 KiB
C
/*
|
|
* Copyright 2014, Michael Ellerman, IBM Corp.
|
|
* Licensed under GPLv2.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include "trace.h"
|
|
|
|
|
|
struct trace_buffer *trace_buffer_allocate(u64 size)
|
|
{
|
|
struct trace_buffer *tb;
|
|
|
|
if (size < sizeof(*tb)) {
|
|
fprintf(stderr, "Error: trace buffer too small\n");
|
|
return NULL;
|
|
}
|
|
|
|
tb = mmap(NULL, size, PROT_READ | PROT_WRITE,
|
|
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
|
|
if (tb == MAP_FAILED) {
|
|
perror("mmap");
|
|
return NULL;
|
|
}
|
|
|
|
tb->size = size;
|
|
tb->tail = tb->data;
|
|
tb->overflow = false;
|
|
|
|
return tb;
|
|
}
|
|
|
|
static bool trace_check_bounds(struct trace_buffer *tb, void *p)
|
|
{
|
|
return p < ((void *)tb + tb->size);
|
|
}
|
|
|
|
static bool trace_check_alloc(struct trace_buffer *tb, void *p)
|
|
{
|
|
/*
|
|
* If we ever overflowed don't allow any more input. This prevents us
|
|
* from dropping a large item and then later logging a small one. The
|
|
* buffer should just stop when overflow happened, not be patchy. If
|
|
* you're overflowing, make your buffer bigger.
|
|
*/
|
|
if (tb->overflow)
|
|
return false;
|
|
|
|
if (!trace_check_bounds(tb, p)) {
|
|
tb->overflow = true;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void *trace_alloc(struct trace_buffer *tb, int bytes)
|
|
{
|
|
void *p, *newtail;
|
|
|
|
p = tb->tail;
|
|
newtail = tb->tail + bytes;
|
|
if (!trace_check_alloc(tb, newtail))
|
|
return NULL;
|
|
|
|
tb->tail = newtail;
|
|
|
|
return p;
|
|
}
|
|
|
|
static struct trace_entry *trace_alloc_entry(struct trace_buffer *tb, int payload_size)
|
|
{
|
|
struct trace_entry *e;
|
|
|
|
e = trace_alloc(tb, sizeof(*e) + payload_size);
|
|
if (e)
|
|
e->length = payload_size;
|
|
|
|
return e;
|
|
}
|
|
|
|
int trace_log_reg(struct trace_buffer *tb, u64 reg, u64 value)
|
|
{
|
|
struct trace_entry *e;
|
|
u64 *p;
|
|
|
|
e = trace_alloc_entry(tb, sizeof(reg) + sizeof(value));
|
|
if (!e)
|
|
return -ENOSPC;
|
|
|
|
e->type = TRACE_TYPE_REG;
|
|
p = (u64 *)e->data;
|
|
*p++ = reg;
|
|
*p++ = value;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int trace_log_counter(struct trace_buffer *tb, u64 value)
|
|
{
|
|
struct trace_entry *e;
|
|
u64 *p;
|
|
|
|
e = trace_alloc_entry(tb, sizeof(value));
|
|
if (!e)
|
|
return -ENOSPC;
|
|
|
|
e->type = TRACE_TYPE_COUNTER;
|
|
p = (u64 *)e->data;
|
|
*p++ = value;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int trace_log_string(struct trace_buffer *tb, char *str)
|
|
{
|
|
struct trace_entry *e;
|
|
char *p;
|
|
int len;
|
|
|
|
len = strlen(str);
|
|
|
|
/* We NULL terminate to make printing easier */
|
|
e = trace_alloc_entry(tb, len + 1);
|
|
if (!e)
|
|
return -ENOSPC;
|
|
|
|
e->type = TRACE_TYPE_STRING;
|
|
p = (char *)e->data;
|
|
memcpy(p, str, len);
|
|
p += len;
|
|
*p = '\0';
|
|
|
|
return 0;
|
|
}
|
|
|
|
int trace_log_indent(struct trace_buffer *tb)
|
|
{
|
|
struct trace_entry *e;
|
|
|
|
e = trace_alloc_entry(tb, 0);
|
|
if (!e)
|
|
return -ENOSPC;
|
|
|
|
e->type = TRACE_TYPE_INDENT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int trace_log_outdent(struct trace_buffer *tb)
|
|
{
|
|
struct trace_entry *e;
|
|
|
|
e = trace_alloc_entry(tb, 0);
|
|
if (!e)
|
|
return -ENOSPC;
|
|
|
|
e->type = TRACE_TYPE_OUTDENT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void trace_print_header(int seq, int prefix)
|
|
{
|
|
printf("%*s[%d]: ", prefix, "", seq);
|
|
}
|
|
|
|
static char *trace_decode_reg(int reg)
|
|
{
|
|
switch (reg) {
|
|
case 769: return "SPRN_MMCR2"; break;
|
|
case 770: return "SPRN_MMCRA"; break;
|
|
case 779: return "SPRN_MMCR0"; break;
|
|
case 804: return "SPRN_EBBHR"; break;
|
|
case 805: return "SPRN_EBBRR"; break;
|
|
case 806: return "SPRN_BESCR"; break;
|
|
case 800: return "SPRN_BESCRS"; break;
|
|
case 801: return "SPRN_BESCRSU"; break;
|
|
case 802: return "SPRN_BESCRR"; break;
|
|
case 803: return "SPRN_BESCRRU"; break;
|
|
case 771: return "SPRN_PMC1"; break;
|
|
case 772: return "SPRN_PMC2"; break;
|
|
case 773: return "SPRN_PMC3"; break;
|
|
case 774: return "SPRN_PMC4"; break;
|
|
case 775: return "SPRN_PMC5"; break;
|
|
case 776: return "SPRN_PMC6"; break;
|
|
case 780: return "SPRN_SIAR"; break;
|
|
case 781: return "SPRN_SDAR"; break;
|
|
case 768: return "SPRN_SIER"; break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void trace_print_reg(struct trace_entry *e)
|
|
{
|
|
u64 *p, *reg, *value;
|
|
char *name;
|
|
|
|
p = (u64 *)e->data;
|
|
reg = p++;
|
|
value = p;
|
|
|
|
name = trace_decode_reg(*reg);
|
|
if (name)
|
|
printf("register %-10s = 0x%016llx\n", name, *value);
|
|
else
|
|
printf("register %lld = 0x%016llx\n", *reg, *value);
|
|
}
|
|
|
|
static void trace_print_counter(struct trace_entry *e)
|
|
{
|
|
u64 *value;
|
|
|
|
value = (u64 *)e->data;
|
|
printf("counter = %lld\n", *value);
|
|
}
|
|
|
|
static void trace_print_string(struct trace_entry *e)
|
|
{
|
|
char *str;
|
|
|
|
str = (char *)e->data;
|
|
puts(str);
|
|
}
|
|
|
|
#define BASE_PREFIX 2
|
|
#define PREFIX_DELTA 8
|
|
|
|
static void trace_print_entry(struct trace_entry *e, int seq, int *prefix)
|
|
{
|
|
switch (e->type) {
|
|
case TRACE_TYPE_REG:
|
|
trace_print_header(seq, *prefix);
|
|
trace_print_reg(e);
|
|
break;
|
|
case TRACE_TYPE_COUNTER:
|
|
trace_print_header(seq, *prefix);
|
|
trace_print_counter(e);
|
|
break;
|
|
case TRACE_TYPE_STRING:
|
|
trace_print_header(seq, *prefix);
|
|
trace_print_string(e);
|
|
break;
|
|
case TRACE_TYPE_INDENT:
|
|
trace_print_header(seq, *prefix);
|
|
puts("{");
|
|
*prefix += PREFIX_DELTA;
|
|
break;
|
|
case TRACE_TYPE_OUTDENT:
|
|
*prefix -= PREFIX_DELTA;
|
|
if (*prefix < BASE_PREFIX)
|
|
*prefix = BASE_PREFIX;
|
|
trace_print_header(seq, *prefix);
|
|
puts("}");
|
|
break;
|
|
default:
|
|
trace_print_header(seq, *prefix);
|
|
printf("entry @ %p type %d\n", e, e->type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void trace_buffer_print(struct trace_buffer *tb)
|
|
{
|
|
struct trace_entry *e;
|
|
int i, prefix;
|
|
void *p;
|
|
|
|
printf("Trace buffer dump:\n");
|
|
printf(" address %p \n", tb);
|
|
printf(" tail %p\n", tb->tail);
|
|
printf(" size %llu\n", tb->size);
|
|
printf(" overflow %s\n", tb->overflow ? "TRUE" : "false");
|
|
printf(" Content:\n");
|
|
|
|
p = tb->data;
|
|
|
|
i = 0;
|
|
prefix = BASE_PREFIX;
|
|
|
|
while (trace_check_bounds(tb, p) && p < tb->tail) {
|
|
e = p;
|
|
|
|
trace_print_entry(e, i, &prefix);
|
|
|
|
i++;
|
|
p = (void *)e + sizeof(*e) + e->length;
|
|
}
|
|
}
|
|
|
|
void trace_print_location(struct trace_buffer *tb)
|
|
{
|
|
printf("Trace buffer 0x%llx bytes @ %p\n", tb->size, tb);
|
|
}
|