-
Notifications
You must be signed in to change notification settings - Fork 0
/
error.cpp
167 lines (139 loc) · 4.65 KB
/
error.cpp
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
#include "error.hpp"
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include "utils.hpp"
using namespace std;
// Headers needed for stack dump:
#include <cxxabi.h>
#include <execinfo.h>
#include <execinfo.h>
#include <signal.h>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdlib.h>
#include <string.h>
#include <ucontext.h>
#include <unistd.h>
#include <mpi.h>
void initializeModule_error() {
}
// Function from: <http://blog.aplikacja.info/2010/12/backtraces-for-c/>
/** Print a demangled stack backtrace of the caller function to FILE* out. */
static void print_stacktrace(const char* source, FILE *out = stderr, unsigned int max_frames = 63)
{
char linkname[512]; /* /proc//exe */
char buf[512];
pid_t pid;
int ret;
/* Get our PID and build the name of the link in /proc */
pid = getpid();
snprintf(linkname, sizeof(linkname), "/proc/%i/exe", pid);
/* Now read the symbolic link */
ret = readlink(linkname, buf, 512);
buf[ret] = 0;
fprintf(out, "---------------------------------------------\n");
fprintf(out, "stack trace (%s) for process %s (PID:%d):\n",
source, buf, pid);
// storage array for stack trace address data
void* addrlist[max_frames+1];
// retrieve current stack addresses
int addrlen = backtrace(addrlist, sizeof(addrlist) / sizeof(void*));
if (addrlen == 0) {
fprintf(out, " \n");
return;
}
// resolve addresses into strings containing "filename(function+address)",
// this array must be free()-ed
char** symbollist = backtrace_symbols(addrlist, addrlen);
// allocate string which will be filled with the demangled function name
size_t funcnamesize = 256;
char* funcname = (char*)malloc(funcnamesize);
// iterate over the returned symbol lines. skip first two,
// (addresses of this function and handler)
for (int i = 2; i < addrlen; i++)
{
char *begin_name = 0, *begin_offset = 0, *end_offset = 0;
// find parentheses and +address offset surrounding the mangled name:
// ./module(function+0x15c) [0x8048a6d]
for (char *p = symbollist[i]; *p; ++p)
{
if (*p == '(')
begin_name = p;
else if (*p == '+')
begin_offset = p;
else if (*p == ')' && begin_offset) {
end_offset = p;
break;
}
}
if (begin_name && begin_offset && end_offset
&& begin_name < begin_offset)
{
*begin_name++ = '\0';
*begin_offset++ = '\0';
*end_offset = '\0';
// mangled name is now in [begin_name, begin_offset) and caller
// offset in [begin_offset, end_offset). now apply
// __cxa_demangle():
int status;
char* ret = abi::__cxa_demangle(begin_name,
funcname, &funcnamesize, &status);
if (status == 0) {
funcname = ret; // use possibly realloc()-ed string
fprintf(out, " (PID:%d) %s : %s+%s\n",
pid, symbollist[i], funcname, begin_offset);
}
else {
// demangling failed. Output function name as a C function with
// no arguments.
fprintf(out, " (PID:%d) %s : %s()+%s\n",
pid, symbollist[i], begin_name, begin_offset);
}
}
else
{
// couldn't parse the line? print the whole line.
fprintf(out, " (PID:%d) %s: ??\n", pid, symbollist[i]);
}
}
free(funcname);
free(symbollist);
fprintf(out, "---------------------------------------------\n");
}
Error findError(ERRCODE code) {
// iterate through the global table of error information until we find the one
// with the proper code
for(int i = 0; ; i++) {
if(gErrors[i].code == ERR_NULL) break;
if(gErrors[i].code == code) return gErrors[i];
}
Error e;
e.code = ERR_UNCLASSIFIED;
e.sCode = "ERR_UNCLASSIFIED";
e.msg = "An unclassified error occured.";
return e;
}
void error(ERRCODE code) {
if(isMasterRank()) {
Error err = findError(code);
cerr << hiErr("Encountered error: ") << hiErr(err.sCode) << endl;
cerr << " " << hiErr(err.msg) << endl;
print_stacktrace("gridweaver");
MPI_Abort(MPI_COMM_WORLD, 1);
}
MPI_Barrier(MPI_COMM_WORLD);
}
void error(ERRCODE code, string arg) {
if(isMasterRank()) {
Error err = findError(code);
cerr << hiErr("Encountered error: ") << hiErr(err.sCode) << endl;
cerr << " " << hiErr(err.msg) << endl;
cerr << " " << hiProp("Argument: ") << hiVal(arg) << endl;
print_stacktrace("gridweaver");
MPI_Abort(MPI_COMM_WORLD, 1);
}
MPI_Barrier(MPI_COMM_WORLD);
}