new file: .syntastic_cpp_config
[dyninst.git] / proccontrol / src / pcerrors.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  *
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  *
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30 #include <stdio.h>
31 #include <stdlib.h>
32
33 #include "proccontrol/h/PCErrors.h"
34
35 #include "common/src/dthread.h"
36
37 using namespace Dyninst;
38 using namespace ProcControlAPI;
39
40 static err_t last_error;
41 static const char *last_error_msg;
42 static signed long gen_thrd_id;
43 static signed long handler_thrd_id;
44 static signed long x_thrd_id;
45 static signed long r_thrd_id;
46 static signed long w_thrd_id;
47
48 FILE *pctrl_err_out;
49 //bool dyninst_debug_proccontrol = false;
50 bool dyninst_debug_proccontrol = true;
51 static Mutex<true> print_lock;
52
53 void pc_print_lock()
54 {
55 #if defined(PROCCTRL_LOCK_PRINTS)
56    print_lock.lock();
57 #endif
58 }
59
60 void pc_print_unlock()
61 {
62 #if defined(PROCCTRL_LOCK_PRINTS)
63    print_lock.unlock();
64 #endif
65 }
66
67 const char *thrdName()
68 {
69    signed long self = DThread::self();
70    if (self == gen_thrd_id)
71       return "G";
72    else if (self == handler_thrd_id)
73       return "H";
74    else if (self == x_thrd_id)
75       return "X";
76    else if (self == w_thrd_id)
77       return "W";
78    else if (self == r_thrd_id)
79       return "R";
80    else
81       return "U";
82 }
83
84 #if defined(PROCCTRL_PRINT_TIMINGS)
85 #include <sys/time.h>
86 unsigned long gettod()
87 {
88    static unsigned long long start = 0;
89    static bool start_set = false;
90    struct timeval val;
91    int result = gettimeofday(&val, NULL);
92    if (result == -1)
93       return 0;
94    unsigned long long t = (unsigned long long) ((val.tv_sec * 1000) + (val.tv_usec / 1000));
95    if (!start_set) {
96       start_set = true;
97       start = t;
98    }
99    return (unsigned long) (t - start);
100 }
101 #endif
102
103 void setGeneratorThread(long t)
104 {
105    gen_thrd_id = t;
106 }
107
108 void setHandlerThread(long t)
109 {
110    handler_thrd_id = t;
111 }
112
113 void setXThread(long t)
114 {
115    x_thrd_id = t;
116 }
117
118 void setRThread(long t)
119 {
120    r_thrd_id = t;
121 }
122
123 void setWThread(long t)
124 {
125    w_thrd_id = t;
126 }
127
128 bool isGeneratorThread() {
129    return DThread::self() == gen_thrd_id;
130 }
131
132 bool isHandlerThread() {
133    return DThread::self() == handler_thrd_id;
134 }
135
136 bool isUserThread() {
137    return !isGeneratorThread() && !isHandlerThread();
138 }
139 err_t Dyninst::ProcControlAPI::getLastError()
140 {
141    return last_error;
142 }
143
144 void Dyninst::ProcControlAPI::clearLastError()
145 {
146    last_error = 0;
147 }
148
149 const char *Dyninst::ProcControlAPI::getLastErrorMsg()
150 {
151    return last_error_msg;
152 }
153
154 void Dyninst::ProcControlAPI::globalSetLastError(err_t err, const char *msg)
155 {
156    last_error = err;
157    last_error_msg = msg;
158 }
159
160 void Dyninst::ProcControlAPI::setDebugChannel(FILE *f)
161 {
162    pctrl_err_out = f;
163 }
164
165 void Dyninst::ProcControlAPI::setDebug(bool enable)
166 {
167    dyninst_debug_proccontrol = enable;
168 }
169
170 #define STR_RET(C, S) case C: return S
171 const char *Dyninst::ProcControlAPI::getGenericErrorMsg(err_t e) {
172    switch (e) {
173       STR_RET(err_none, "None");
174       STR_RET(err_badparam, "Bad Parameter");
175       STR_RET(err_procread, "Bad Address");
176       STR_RET(err_internal, "Internal Error");
177       STR_RET(err_prem, "Premission Denied");
178       STR_RET(err_noproc, "No such process");
179       STR_RET(err_interrupt, "Operation Interrupted");
180       STR_RET(err_exited, "Process or Thread is Exited");
181       STR_RET(err_nofile, "No such file or directory");
182       STR_RET(err_unsupported, "Unsupported feature on this platform");
183       STR_RET(err_symtab, "Error during symbol table reading");
184       STR_RET(err_nothrd, "No such thread");
185       STR_RET(err_notstopped, "Process or Thread is not stopped");
186       STR_RET(err_notrunning, "Process or Thread is not running");
187       STR_RET(err_noevents, "No events were available to be handled");
188       STR_RET(err_incallback, "Illegal operation issued from callback");
189       STR_RET(err_nouserthrd, "User thread information is not avaiable");
190       STR_RET(err_detached, "Process is detached");
191       STR_RET(err_attached, "Process is already attached");
192       STR_RET(err_pendingirpcs, "IRPCs are pending");
193       default: return "Unknown";
194    }
195 }
196
197 class init_debug_channel
198 {
199 public:
200    init_debug_channel()
201    {
202       pctrl_err_out = stderr;
203       char *debug = getenv("DYNINST_DEBUG_PROCCONTROL");
204       if (debug && atoi(debug)) {
205          setDebug(true);
206       }
207    }
208 };
209 static init_debug_channel idc;
210