1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
/*
*
* Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the License);
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Authors: Adrian Szyndela <adrian.s@samsung.com>
* Rafal Pietruch <r.pietruch@samsung.com>
* Łukasz Stelmach <l.stelmach@samsung.com>
*/
/**
* @file crash-stack-arm.c
* @brief unwinding call stacks, functions specific for ARM
*/
#include "crash-stack.h"
#include <elf.h>
#include <stdio.h>
#include <string.h>
#include <sys/ptrace.h>
#include <sys/user.h>
// definitions copied from previously used McTernan unwinder
#define REGS_REGULAR_NUM 13
#define REG_FP 11
#define REG_IP 12
#define REG_SP 13
#define REG_LR 14
#define REG_PC 15
#define REG_SPSR 16
/**
* @brief Important registers for unwinding stack on ARM
*/
struct Regs {
Elf64_Addr regs[REGS_REGULAR_NUM]; ///< regular registers
Elf64_Addr sp; ///< register: stack pointer
Elf64_Addr lr; ///< register: link register
Elf64_Addr pc; ///< register: program counter
Elf64_Addr spsr; ///< register: status register
};
typedef struct Regs Regs; ///< convenience type definition
static Regs g_regs; ///< static storage for target register values
static struct user_regs g_ptrace_registers; ///< static storage for ptrace buffer for registers
void *_crash_stack_get_memory_for_ptrace_registers(size_t *size)
{
if (NULL != size)
*size = sizeof(g_ptrace_registers);
return &g_ptrace_registers;
}
void *_get_place_for_register_value(const char *regname, int regnum)
{
if (strcmp(regname, "pc") == 0 || REG_PC == regnum)
return &g_regs.pc;
else if (strcmp(regname, "sp") == 0 || REG_SP == regnum)
return &g_regs.sp;
else if (strcmp(regname, "lr") == 0 || REG_LR == regnum)
return &g_regs.lr;
else if (strcmp(regname, "spsr") == 0 || REG_SPSR == regnum)
return &g_regs.spsr;
else if (regnum < REGS_REGULAR_NUM)
return &g_regs.regs[regnum];
return NULL;
}
void _crash_stack_set_ptrace_registers(void *regbuf)
{
struct user_regs *registers = regbuf;
int i;
for (i = 0; i < sizeof(registers->uregs)/sizeof(registers->uregs[0]); i++) {
void *regmem = _get_place_for_register_value("", i);
if (NULL != regmem)
memcpy(regmem, ®isters->uregs[i], sizeof(registers->uregs[i]));
}
}
void _crash_stack_print_regs(FILE* outputfile)
{
fprintf(outputfile, "\nRegister Information\n");
fprintf(outputfile, "r0 = 0x%08lx, r1 = 0x%08lx\nr2 = 0x%08lx, r3 = 0x%08lx\n",
g_ptrace_registers.uregs[0], g_ptrace_registers.uregs[1],
g_ptrace_registers.uregs[2], g_ptrace_registers.uregs[3]);
fprintf(outputfile, "r4 = 0x%08lx, r5 = 0x%08lx\nr6 = 0x%08lx, r7 = 0x%08lx\n",
g_ptrace_registers.uregs[4], g_ptrace_registers.uregs[5],
g_ptrace_registers.uregs[6], g_ptrace_registers.uregs[7]);
fprintf(outputfile, "r8 = 0x%08lx, r9 = 0x%08lx\nr10 = 0x%08lx, fp = 0x%08lx\n",
g_ptrace_registers.uregs[8], g_ptrace_registers.uregs[9],
g_ptrace_registers.uregs[10], g_ptrace_registers.uregs[REG_FP]);
fprintf(outputfile, "ip = 0x%08lx, sp = 0x%08lx\nlr = 0x%08lx, pc = 0x%08lx\n",
g_ptrace_registers.uregs[REG_IP], g_ptrace_registers.uregs[REG_SP],
g_ptrace_registers.uregs[REG_LR], g_ptrace_registers.uregs[REG_PC]);
/* XXX the label should probably write "spsr" */
fprintf(outputfile, "cpsr = 0x%08lx\n", g_ptrace_registers.uregs[REG_SPSR]);
}
|
