summaryrefslogtreecommitdiff
path: root/src/lib/eina/eina_debug_bt.c
blob: a2510e9123553301a1c303e3f09f5a26f3912163 (plain)
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
/* EINA - EFL data type library
 * Copyright (C) 2015 Carsten Haitzler
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library;
 * if not, see <http://www.gnu.org/licenses/>.
 */

# ifdef HAVE_CONFIG_H
#  include "config.h"
# endif

#ifdef HAVE_DLADDR
# ifdef _WIN32
#  include <evil_private.h> /* dladdr */
# else
#  include <dlfcn.h>
# endif
#endif

#ifdef HAVE_UNWIND
#include <libunwind.h>
#endif

#include "eina_debug.h"
#include "eina_debug_private.h"

#ifndef _WIN32
# include <signal.h>
// realtime signals guarantee a minimum of 8, so SIGRTMIN + 7 would be valid
// at a minimum, so let's choose + 6 ... second last of the minimum set.
// SIGRTMAX of course is defined too... note the manual pages for sigation say
// that it calls rt_sigaction transparently for us so... no need for anything
// else special
# ifdef SIGRTMIN
#  define SIG (SIGRTMIN + 6)
# else
// OSX seems to not support posix RT signals... too old a kernel. so be partly
// broken on OSX in that a HUP signal will maybe cause a crash... but compiling
// with -pg would have guaranteed always caused a crash before anyway.
// given OSX only supports "old-style" signals like:
// 
// #define  SIGHUP     1 /* hangup */
// #define  SIGINT     2 /* interrupt */
// #define  SIGQUIT    3 /* quit */
// #define  SIGILL     4 /* illegal instruction (not reset when caught) */
// #define  SIGTRAP    5 /* trace trap (not reset when caught) */
// #define  SIGABRT    6 /* abort() */
// #if  (defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE))
// # define SIGPOLL    7 /* pollable event ([XSR] generated, not supported) */
// #else /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
// # define SIGIOT     SIGABRT /* compatibility */
// # define SIGEMT     7 /* EMT instruction */
// #endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
// #define  SIGFPE     8 /* floating point exception */
// #define  SIGKILL    9 /* kill (cannot be caught or ignored) */
// #define  SIGBUS    10 /* bus error */
// #define  SIGSEGV   11 /* segmentation violation */
// #define  SIGSYS    12 /* bad argument to system call */
// #define  SIGPIPE   13 /* write on a pipe with no one to read it */
// #define  SIGALRM   14 /* alarm clock */
// #define  SIGTERM   15 /* software termination signal from kill */
// #define  SIGURG    16 /* urgent condition on IO channel */
// #define  SIGSTOP   17 /* sendable stop signal not from tty */
// #define  SIGTSTP   18 /* stop signal from tty */
// #define  SIGCONT   19 /* continue a stopped process */
// #define  SIGCHLD   20 /* to parent on child stop or exit */
// #define  SIGTTIN   21 /* to readers pgrp upon background tty read */
// #define  SIGTTOU   22 /* like TTIN for output if (tp->t_local&LTOSTOP) */
// #if  (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
// # define SIGIO     23 /* input/output possible signal */
// #endif
// #define  SIGXCPU   24 /* exceeded CPU time limit */
// #define  SIGXFSZ   25 /* exceeded file size limit */
// #define  SIGVTALRM 26 /* virtual time alarm */
// #define  SIGPROF   27 /* profiling time alarm */
// #if  (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
// # define SIGWINCH  28 /* window size changes */
// # define SIGINFO   29 /* information request */
// #endif
// #define  SIGUSR1   30 /* user defined signal 1 */
// #define  SIGUSR2   31 /* user defined signal 2 */
// 
// (excerpt from OSX's signal.h - found at:
// http://github.com/st3fan/osx-10.9/blob/master/xnu-2422.1.72/bsd/sys/signal.h
// pasting here due to how difficult it was to find a signal list for OSX)
#  define SIG SIGHUP
# endif
#endif

static Eina_Semaphore _wait_for_bts_sem;

// _bt_buf[0] is always for mainloop, 1 + is for extra threads
static void             ***_bt_buf;
static int                *_bt_buf_len;
static struct timespec    *_bt_ts;
static int                *_bt_cpu;

/* Used by trace timer */
static double _trace_t0 = 0.0;
static Eina_Debug_Timer *_timer = NULL;

#ifndef _WIN32
static struct sigaction old_sigprof_action;
#endif

void
_eina_debug_dump_fhandle_bt(FILE *f, void **bt, int btlen)
{
#ifndef _WIN32
   int i;
   Dl_info info;
   const char *file;
   unsigned long long offset, base;

   for (i = 0; i < btlen; i++)
     {
        file = NULL;
        offset = base = 0;
        // we have little choice but to hope/assume dladdr() doesn't alloc
        // anything here
        if ((dladdr(bt[i], &info)) && (info.dli_fname) && (info.dli_fname[0]))
          {
             offset = (unsigned long long)(uintptr_t)bt[i];
             base = (unsigned long long)(uintptr_t)info.dli_fbase;
             file = _eina_debug_file_get(info.dli_fname);
          }
        // rely on normal libc buffering for file ops to avoid syscalls.
        // may or may not be a good idea. good enough for now.
        if (file) fprintf(f, "%s\t 0x%llx 0x%llx\n", file, offset, base);
        else fprintf(f, "??\t -\n");
     }
#else
   (void)f;
   (void)bt;
   (void)btlen;
#endif
}

// a backtracer that uses libunwind to do the job
static inline int
_eina_debug_unwind_bt(void **bt, int max)
{
#ifdef HAVE_UNWIND
   unw_cursor_t cursor;
   unw_context_t uc;
   unw_word_t p;
   int total;

   // create a context for unwinding
   unw_getcontext(&uc);
   // begin our work
   unw_init_local(&cursor, &uc);
   // walk up each stack frame until there is no more, storing it
   for (total = 0; (unw_step(&cursor) > 0) && (total < max); total++)
     {
        unw_get_reg(&cursor, UNW_REG_IP, &p);
        bt[total] = (void *)p;
     }
   // return our total backtrace stack size
   return total;
#else
   (void)bt;
   (void)max;
   return 0;
#endif
}

// a quick and dirty local time point getter func - not portable
static inline double
get_time(void)
{
#if defined(__clockid_t_defined)
   struct timespec t;
   clock_gettime(CLOCK_MONOTONIC, &t);
   return (double)t.tv_sec + (((double)t.tv_nsec) / 1000000000.0);
#else
   struct timeval timev;
   gettimeofday(&timev, NULL);
   return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000.0);
#endif
}

#ifndef _WIN32
static void
_signal_handler(int sig EINA_UNUSED,
      siginfo_t *si EINA_UNUSED, void *foo EINA_UNUSED)
{
   int i, slot = 0;
   pthread_t self = pthread_self();
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_SCHED_GETCPU) && defined(__clockid_t_defined)
   clockid_t cid;
#endif

   // find which slot in the array of threads we have so we store info
   // in the correct slot for us
   for (i = 0; i < _eina_debug_thread_active_num; i++)
     {
        if (self == _eina_debug_thread_active[i].thread)
          {
             slot = i;
             goto found;
          }
     }
   // we couldn't find out thread reference! help!
   e_debug("EINA DEBUG ERROR: can't find thread slot!");
   eina_semaphore_release(&_wait_for_bts_sem, 1);
   return;
found:
   /*
    * Below is very non-portable code!
    *
    * - clock_gettime() is not implemented on macOS < 10.12
    * - sched_getcpu() is not implemented on macOS
    * - pthread_getcpuclockid() is not implemented on macOS
    * - CLOCK_THREAD_CPUTIME_ID should be identical to pthread_getcpuclockid(),
    *   but it requires POSIX thingies to be defined.
    */
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_SCHED_GETCPU) && defined(__clockid_t_defined)
   // store thread info like what cpu core we are on now (not reliable
   // but hey - better than nothing), the amount of cpu time total
   // we have consumed (it's cumulative so subtracing deltas can give
   // you an average amount of cpu time consumed between now and the
   // previous time we looked) and also a full backtrace
   _bt_cpu[slot] = sched_getcpu();
# ifdef HAVE_PTHREAD_GETCPUCLOCKID
   /* Try pthread_getcpuclockid() first */
   pthread_getcpuclockid(self, &cid);
# elif defined(_POSIX_THREAD_CPUTIME)
   /* Fallback to POSIX clock id. */
   cid = CLOCK_THREAD_CPUTIME_ID;
# else
   /* Boom, we lost */
#  error Cannot determine the clock id for clock_gettime()
# endif
   clock_gettime(cid, &(_bt_ts[slot]));
   _bt_buf_len[slot] = _eina_debug_unwind_bt(_bt_buf[slot], EINA_MAX_BT);
#endif /* HAVE_CLOCK_GETTIME && HAVE_SCHED_GETCPU */
   // now wake up the monitor to let them know we are done collecting our
   // backtrace info
   eina_semaphore_release(&_wait_for_bts_sem, 1);
}
#endif

static void
_signal_init(void)
{
#ifndef _WIN32
   struct sigaction sa;

   memset(&sa, 0, sizeof(struct sigaction));

   sa.sa_handler = SIG_DFL;
   sa.sa_sigaction = NULL;
   sa.sa_flags = SA_RESTART | SA_SIGINFO;
   sigemptyset(&sa.sa_mask);
   sigaction(SIG, &sa, &old_sigprof_action);

   memset(&sa, 0, sizeof(struct sigaction));
   // set up signal handler for our profiling signal - eevery thread should
   // obey this (this is the case on linux - other OSs may vary)
   sa.sa_sigaction = _signal_handler;
   sa.sa_flags = SA_RESTART | SA_SIGINFO;
   sigemptyset(&sa.sa_mask);
   if (sigaction(SIG, &sa, NULL) != 0)
      e_debug("EINA DEBUG ERROR: Can't set up sig %i handler!", SIG);

   sa.sa_sigaction = NULL;
   sa.sa_handler = SIG_IGN;
   sigemptyset(&sa.sa_mask);
   sa.sa_flags = 0;
   if (sigaction(SIGPIPE, &sa, 0) == -1) perror(0);
#endif
}

static void
_signal_shutdown(void)
{
#ifndef _WIN32
   sigaction(SIG, &old_sigprof_action, NULL);
#endif
}

static void
_collect_bt(pthread_t pth)
{
   // this async signals the thread to switch to the deebug signal handler
   // and collect a backtrace and other info from inside the thread
#ifndef _WIN32
   pthread_kill(pth, SIG);
#endif
}

static Eina_Bool
_trace_cb(void *data EINA_UNUSED)
{
   static int bts = 0;
   int i;

   if (!_trace_t0) _trace_t0 = get_time();

   // take a lock on grabbing thread debug info like backtraces
   eina_spinlock_take(&_eina_debug_thread_lock);
   // too many threads (over 1 million) !!!!
   if (_eina_debug_thread_active_num > (1024 * 1024)) goto err;
   // reset our "stack" of memory se use to dump thread info into
   _eina_debug_chunk_tmp_reset();
   // get an array of pointers for the backtrace array for main + th
   _bt_buf = _eina_debug_chunk_tmp_push
      ((_eina_debug_thread_active_num) * sizeof(void *));
   if (!_bt_buf) goto err;
   // get an array of pointers for the timespec array for mainloop + th
   _bt_ts = _eina_debug_chunk_tmp_push
      ((_eina_debug_thread_active_num) * sizeof(struct timespec));
   if (!_bt_ts) goto err;
   // get an array of pointers for the cpuid array for mainloop + th
   _bt_cpu = _eina_debug_chunk_tmp_push
      ((_eina_debug_thread_active_num) * sizeof(int));
   if (!_bt_cpu) goto err;
   // get an array of void ptrs for each thread we know about for bt
   for (i = 0; i < _eina_debug_thread_active_num; i++)
     {
        _bt_buf[i] = _eina_debug_chunk_tmp_push(EINA_MAX_BT * sizeof(void *));
        if (!_bt_buf[i]) goto err;
     }
   // get an array of ints to stor the bt len for mainloop + threads
   _bt_buf_len = _eina_debug_chunk_tmp_push
      ((_eina_debug_thread_active_num) * sizeof(int));
   // now collect per thread
   for (i = 0; i < _eina_debug_thread_active_num; i++)
      _collect_bt(_eina_debug_thread_active[i].thread);
   // we're done probing. now collec all the "i'm done" msgs on the
   // semaphore for every thread + mainloop
   for (i = 0; i < (_eina_debug_thread_active_num); i++)
      eina_semaphore_lock(&_wait_for_bts_sem);
   // we now have gotten all the data from all threads
   // we can process it now as we see fit, so release thread lock
   for (i = 0; i < _eina_debug_thread_active_num; i++)
     {
        _eina_debug_dump_fhandle_bt(stderr, _bt_buf[i], _bt_buf_len[i]);
     }
err:
   eina_spinlock_release(&_eina_debug_thread_lock);
   //// XXX: some debug just to see how well we perform - will go
   bts++;
   if (bts >= 10000)
     {
        double t;
        t = get_time();
        e_debug("%1.5f bt's per sec", (double)bts / (t - _trace_t0));
        _trace_t0 = t;
        bts = 0;
     }
   return EINA_TRUE;
}

// profiling on with poll time gap as uint payload
static Eina_Bool
_prof_on_cb(Eina_Debug_Session *session, int cid EINA_UNUSED, void *buffer, int size)
{
   unsigned int time;

   _signal_init();
   if (size >= 4)
     {
        memcpy(&time, buffer, 4);
        _trace_t0 = 0.0;
        if (_timer) eina_debug_timer_del(_timer);
        _timer = eina_debug_timer_add(time, _trace_cb, session);
     }
   return EINA_TRUE;
}

static Eina_Bool
_prof_off_cb(Eina_Debug_Session *session EINA_UNUSED, int cid EINA_UNUSED, void *buffer EINA_UNUSED, int size EINA_UNUSED)
{
   eina_debug_timer_del(_timer);
   _timer = NULL;
   _signal_shutdown();
   return EINA_TRUE;
}

EINA_DEBUG_OPCODES_ARRAY_DEFINE(_OPS,
      {"Profiler/on", NULL, &_prof_on_cb},
      {"Profiler/off", NULL, &_prof_off_cb},
      {NULL, NULL, NULL}
);

Eina_Bool
_eina_debug_bt_init(void)
{
   eina_semaphore_new(&_wait_for_bts_sem, 0);
   eina_debug_opcodes_register(NULL, _OPS(), NULL, NULL);
   return EINA_TRUE;
}

Eina_Bool
_eina_debug_bt_shutdown(void)
{
   eina_semaphore_free(&_wait_for_bts_sem);
   return EINA_TRUE;
}