6122165118

Committed 08 Sep 2023 01:10PM UTC coverage: 88.109% (-0.1%) from 88.239%

Build # 6122165118

Build Type

push

github

Committed by

fckxorg

Commit Message

Fix frame for more types of on-trace error messages.

Thanks to Maxim Kokryashkin.

(cherry-picked from commit d5bbf9cdb)

This patch fixes the same issue with frame, as the previous
one, but now for the table overflow error in the `err_msgv`
function. The test for the problem uses the table of GC
finalizers, although they are not required to reproduce the
issue. They only used to make the test as simple as possible.

Resolves tarantool/tarantool#562
Part of tarantool/tarantool#8825

Run Details

5338 of 5971 branches covered (0.0%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

20447 of 23294 relevant lines covered (87.78%)

2739190.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.44

/src/lj_sysprof.c

/*
** Implementation of sysprof - platform and Lua profiler.
*/

#define lj_sysprof_c
#define LUA_CORE

#include "lj_arch.h"
#include "lj_sysprof.h"

#if LJ_HASSYSPROF

#include "lj_obj.h"
#include "lj_debug.h"
#include "lj_dispatch.h"
#include "lj_frame.h"

#if LJ_HASJIT
#include "lj_jit.h"
#include "lj_trace.h"
#endif

#include "lj_wbuf.h"
#include "lj_profile_timer.h"
#include "lj_symtab.h"

#include <pthread.h>
#include <errno.h>
#include <execinfo.h>

/*
** Number of profiler frames we need to omit during stack
** unwinding.
**   +------------------------+
** 0 | default_backtrace_host |
**   +------------------------+
** 1 | stream_backtrace_host  |
**   +------------------------+
** 2 |  stream_{guest/host}   |
**   +------------------------+
** 3 |      stream_event      |
**   +------------------------+
** 4 | sysprof_record_sample  |
**   +------------------------+
** 5 | sysprof_signal_handler |
**   +------------------------+
*/
#define SYSPROF_HANDLER_STACK_DEPTH 6
#define SYSPROF_BACKTRACE_FRAME_MAX 512

/* Check that vmstate fits in 4 bits (see streaming format) */
#define vmstfit4(st) ((st & ~(uint32_t)((1 << 4) - 1)) == 0)

enum sysprof_state {
  /* Profiler is not running. */
  SPS_IDLE,
  /* Profiler is running. */
  SPS_PROFILE,
  /*
  ** Stopped in case of stopped or failed stream.
  ** Saved errno is set at luaM_sysprof_stop.
  */
  SPS_HALT
};

struct sysprof {
  global_State *g; /* Profiled VM. */
  pthread_t thread; /* Profiled thread. */
  volatile sig_atomic_t state; /* Internal state. */
  struct lj_wbuf out; /* Output accumulator. */
  struct luam_Sysprof_Counters counters; /* Profiling counters. */
  struct luam_Sysprof_Options opt; /* Profiling options. */
  luam_Sysprof_writer writer; /* Writer function for profile events. */
  luam_Sysprof_on_stop on_stop; /* Callback on profiling stopping. */
  luam_Sysprof_backtracer backtracer; /* Backtracing function for the host stack. */
  lj_profile_timer timer; /* Profiling timer. */
  int saved_errno; /* Saved errno when profiler failed. */
  uint32_t lib_adds; /* Number of libs loaded. Monotonic. */
};
/*
** XXX: Only one VM can be profiled at a time.
*/

static struct sysprof sysprof = {0};

/* --- Stream ------------------------------------------------------------- */

static const uint8_t ljp_header[] = {'l', 'j', 'p', LJP_FORMAT_VERSION,
                                      0x0, 0x0, 0x0};

static int stream_is_needed(struct sysprof *sp)
{
  return sp->opt.mode != LUAM_SYSPROF_DEFAULT;
}

static int is_unconfigured(struct sysprof *sp)
{
  return sp->backtracer == NULL || sp->on_stop == NULL || sp->writer == NULL;
}

static void stream_prologue(struct sysprof *sp)
{
  lj_symtab_dump(&sp->out, sp->g, &sp->lib_adds);
  lj_wbuf_addn(&sp->out, ljp_header, sizeof(ljp_header));
}

static void stream_epilogue(struct sysprof *sp)
{
  lj_wbuf_addbyte(&sp->out, LJP_EPILOGUE_BYTE);
}

static void stream_lfunc(struct lj_wbuf *buf, const GCfunc *func)
{
  lj_assertX(isluafunc(func), "bad lua function in sysprof stream");
  const GCproto *pt = funcproto(func);
  lj_assertX(pt != NULL, "bad lua function prototype in sysprof stream");
  lj_wbuf_addbyte(buf, LJP_FRAME_LFUNC);
  lj_wbuf_addu64(buf, (uintptr_t)pt);
  lj_wbuf_addu64(buf, (uint64_t)pt->firstline);
}

static void stream_cfunc(struct lj_wbuf *buf, const GCfunc *func)
{
  lj_assertX(iscfunc(func), "bad C function in sysprof stream");
  lj_wbuf_addbyte(buf, LJP_FRAME_CFUNC);
  lj_wbuf_addu64(buf, (uintptr_t)func->c.f);
}

static void stream_ffunc(struct lj_wbuf *buf, const GCfunc *func)
{
  lj_assertX(isffunc(func), "bad fast function in sysprof stream");
  lj_wbuf_addbyte(buf, LJP_FRAME_FFUNC);
  lj_wbuf_addu64(buf, func->c.ffid);
}

static void stream_frame_lua(struct lj_wbuf *buf, const cTValue *frame)
{
  const GCfunc *func = frame_func(frame);
  lj_assertX(func != NULL, "bad function in sysprof stream");
  if (isluafunc(func))
    stream_lfunc(buf, func);
  else if (isffunc(func))
    stream_ffunc(buf, func);
  else if (iscfunc(func))
    stream_cfunc(buf, func);
  else
    /* Unreachable. */
    lj_assertX(0, "bad function type in sysprof stream");
}

static void stream_backtrace_lua(struct sysprof *sp)
{
  global_State *g = sp->g;
  struct lj_wbuf *buf = &sp->out;
  cTValue *top_frame = NULL, *frame = NULL, *bot = NULL;
  lua_State *L = NULL;

  lj_assertX(g != NULL, "uninitialized global state in sysprof state");
  L = gco2th(gcref(g->cur_L));
  lj_assertG(L != NULL, "uninitialized Lua state in sysprof state");

  top_frame = g->top_frame - 1; //(1 + LJ_FR2)

  bot = tvref(L->stack) + LJ_FR2;
  /* Traverse frames backwards */
  for (frame = top_frame; frame > bot; frame = frame_prev(frame)) {
    if (frame_gc(frame) == obj2gco(L) || frame_isvarg(frame))
      continue;  /* Skip dummy frames. See lj_err_optype_call(). */
    stream_frame_lua(buf, frame);
  }

  lj_wbuf_addbyte(buf, LJP_FRAME_LUA_LAST);
}

static void *stream_frame_host(int frame_no, void *addr)
{
  struct sysprof *sp = &sysprof;
  /*
  ** We don't want the profiler stack to be streamed, as it will
  ** burden the profile with unnecessary information.
  */
  if (LJ_UNLIKELY(frame_no <= SYSPROF_HANDLER_STACK_DEPTH))
    return addr;
  else if (LJ_UNLIKELY(sp->opt.mode == LUAM_SYSPROF_LEAF &&
                         frame_no > SYSPROF_HANDLER_STACK_DEPTH))
    return NULL;

  lj_wbuf_addu64(&sp->out, (uintptr_t)addr);
  return addr;
}

static void default_backtrace_host(void *(writer)(int frame_no, void *addr))
{
  static void *backtrace_buf[SYSPROF_BACKTRACE_FRAME_MAX] = {};

  struct sysprof *sp = &sysprof;
  int max_depth = sp->opt.mode == LUAM_SYSPROF_LEAF
                  ? SYSPROF_HANDLER_STACK_DEPTH + 1
                  : SYSPROF_BACKTRACE_FRAME_MAX;
  const int depth = backtrace(backtrace_buf, max_depth);
  int level;

  lj_assertX(depth <= max_depth, "depth of C stack is too big");
  for (level = SYSPROF_HANDLER_STACK_DEPTH; level < depth; ++level) {
    if (!writer(level - SYSPROF_HANDLER_STACK_DEPTH + 1, backtrace_buf[level]))
      return;
  }
}

static void stream_backtrace_host(struct sysprof *sp)
{
  lj_assertX(sp->backtracer != NULL, "uninitialized sysprof backtracer");
  sp->backtracer(stream_frame_host);
  lj_wbuf_addu64(&sp->out, (uintptr_t)LJP_FRAME_HOST_LAST);
}

#if LJ_HASJIT
static void stream_trace(struct sysprof *sp, uint32_t vmstate)
{
  lj_wbuf_addbyte(&sp->out, (uint8_t)vmstate);
  struct lj_wbuf *out = &sp->out;
  uint32_t traceno = sp->g->vmstate;
  jit_State *J = G2J(sp->g);
  GCtrace *trace = traceref(J, traceno);

  GCproto *startpt = gco2pt(gcref(trace->startpt));

  lj_wbuf_addu64(out, traceno);
  lj_wbuf_addu64(out, (uintptr_t)startpt);
  lj_wbuf_addu64(out, startpt->firstline);
}
#endif

static void stream_guest(struct sysprof *sp, uint32_t vmstate)
{
  lj_wbuf_addbyte(&sp->out, (uint8_t)vmstate);
  stream_backtrace_lua(sp);
  stream_backtrace_host(sp);
}

static void stream_host(struct sysprof *sp, uint32_t vmstate)
{
  struct lua_State *L = gco2th(gcref(sp->g->cur_L));
  lj_symtab_dump_newc(&sp->lib_adds, &sp->out, LJP_SYMTAB_CFUNC_EVENT, L);
  lj_wbuf_addbyte(&sp->out, (uint8_t)vmstate);
  stream_backtrace_host(sp);
}

typedef void (*event_streamer)(struct sysprof *sp, uint32_t vmstate);

static event_streamer event_streamers[] = {
  /* XXX: order is important */
  stream_host,  /* LJ_VMST_INTERP */
  stream_guest, /* LJ_VMST_LFUNC */
  stream_guest, /* LJ_VMST_FFUNC */
  stream_guest, /* LJ_VMST_CFUNC */
  stream_host,  /* LJ_VMST_GC */
  stream_host,  /* LJ_VMST_EXIT */
  stream_host,  /* LJ_VMST_RECORD */
  stream_host,  /* LJ_VMST_OPT */
  stream_host,  /* LJ_VMST_ASM */
#if LJ_HASJIT
  stream_trace  /* LJ_VMST_TRACE */
#endif
};

static void stream_event(struct sysprof *sp, uint32_t vmstate)
{
  event_streamer stream = NULL;

  lj_assertX(vmstfit4(vmstate), "vmstate don't fit in 4 bits");
  stream = event_streamers[vmstate];
  lj_assertX(stream != NULL, "uninitialized sysprof stream");
  stream(sp, vmstate);
}

/* -- Signal handler ------------------------------------------------------ */

static void sysprof_record_sample(struct sysprof *sp, siginfo_t *info)
{
  global_State *g = sp->g;
  uint32_t _vmstate = ~(uint32_t)(g->vmstate);
  uint32_t vmstate = _vmstate < LJ_VMST_TRACE ? _vmstate : LJ_VMST_TRACE;

  lj_assertX(pthread_self() == sp->thread,
             "bad thread during sysprof record sample");

  /* Caveat: order of counters must match vmstate order in <lj_obj.h>. */
  ((uint64_t *)&sp->counters)[vmstate]++;

  sp->counters.samples++;

  if (!stream_is_needed(sp))
    return;

  stream_event(sp, vmstate);
  if (LJ_UNLIKELY(lj_wbuf_test_flag(&sp->out, STREAM_ERRIO|STREAM_STOP))) {
    sp->saved_errno = lj_wbuf_errno(&sp->out);
    lj_wbuf_terminate(&sp->out);
    sp->state = SPS_HALT;
  }
}

static void sysprof_signal_handler(int sig, siginfo_t *info, void *ctx)
{
  struct sysprof *sp = &sysprof;
  UNUSED(sig);
  UNUSED(ctx);

  switch (sp->state) {
    case SPS_PROFILE:
      sysprof_record_sample(sp, info);
      break;

    case SPS_IDLE:
    case SPS_HALT:
      /* noop */
      break;

    default:
      lj_assertX(0, "bad sysprof profiler state");
      break;
  }
}

/* -- Internal ------------------------------------------------------------ */

static int sysprof_validate(struct sysprof *sp,
                            const struct luam_Sysprof_Options *opt)
{
  switch (sp->state) {
    case SPS_IDLE:
      if (opt->mode > LUAM_SYSPROF_CALLGRAPH) {
        return PROFILE_ERRUSE;
      } else if (opt->mode != LUAM_SYSPROF_DEFAULT &&
                 (opt->buf == NULL || opt->len == 0 || is_unconfigured(sp))) {
        return PROFILE_ERRUSE;
      } else if (opt->interval == 0) {
        return PROFILE_ERRUSE;
      }
      break;

    case SPS_PROFILE:
    case SPS_HALT:
      return PROFILE_ERRRUN;

    default:
      lj_assertX(0, "bad sysprof profiler state");
      break;
  }

  return PROFILE_SUCCESS;
}

static int sysprof_init(struct sysprof *sp, lua_State *L,
                        const struct luam_Sysprof_Options *opt)
{
  const int status = sysprof_validate(sp, opt);
  if (PROFILE_SUCCESS != status)
    return status;

  /* Copy validated options to sysprof state. */
  memcpy(&sp->opt, opt, sizeof(sp->opt));

  /* Init general fields. */
  sp->g = G(L);
  sp->thread = pthread_self();

  /* Reset counters. */
  memset(&sp->counters, 0, sizeof(sp->counters));

  /* Reset saved errno. */
  sp->saved_errno = 0;

  if (stream_is_needed(sp))
    lj_wbuf_init(&sp->out, sp->writer, opt->ctx, opt->buf, opt->len);

  return PROFILE_SUCCESS;
}

/* -- Public profiling API ------------------------------------------------ */

int lj_sysprof_set_writer(luam_Sysprof_writer writer) {
  struct sysprof *sp = &sysprof;

  if (sp->state != SPS_IDLE || writer == NULL)
    return PROFILE_ERRUSE;

  sp->writer = writer;
  if (!is_unconfigured(sp)) {
    sp->state = SPS_IDLE;
  }
  return PROFILE_SUCCESS;
}

int lj_sysprof_set_on_stop(luam_Sysprof_on_stop on_stop) {
  struct sysprof *sp = &sysprof;

  if (sp->state != SPS_IDLE || on_stop == NULL)
    return PROFILE_ERRUSE;

  sp->on_stop = on_stop;
  if (!is_unconfigured(sp)) {
    sp->state = SPS_IDLE;
  }
  return PROFILE_SUCCESS;
}

int lj_sysprof_set_backtracer(luam_Sysprof_backtracer backtracer) {
  struct sysprof *sp = &sysprof;

  if (sp->state != SPS_IDLE)
    return PROFILE_ERRUSE;
  if (backtracer == NULL) {
    sp->backtracer = default_backtrace_host;
    /*
    ** XXX: `backtrace` is not signal-safe, according to man,
    ** because it is lazy loaded on the first call, which triggers
    ** allocations. We need to call `backtrace` before starting profiling
    ** to avoid lazy loading.
    */
    void *dummy = NULL;
    backtrace(&dummy, 1);
  }
  else {
    sp->backtracer = backtracer;
  }
  if (!is_unconfigured(sp)) {
    sp->state = SPS_IDLE;
  }
  return PROFILE_SUCCESS;
}

int lj_sysprof_start(lua_State *L, const struct luam_Sysprof_Options *opt)
{
  struct sysprof *sp = &sysprof;

  int status = sysprof_init(sp, L, opt);
  if (PROFILE_SUCCESS != status) {
    if (NULL != sp->on_stop) {
      /*
      ** Initialization may fail in case of unconfigured sysprof,
      ** so we cannot guarantee cleaning up resources in this case.
      */
      sp->on_stop(opt->ctx, opt->buf);
    }
    return status;
  }

  sp->state = SPS_PROFILE;

  if (stream_is_needed(sp)) {
    stream_prologue(sp);
    if (LJ_UNLIKELY(lj_wbuf_test_flag(&sp->out, STREAM_ERRIO|STREAM_STOP))) {
      /* on_stop call may change errno value. */
      const int saved_errno = lj_wbuf_errno(&sp->out);
      /* Ignore possible errors. mp->out.buf may be NULL here. */
      sp->on_stop(opt->ctx, sp->out.buf);
      lj_wbuf_terminate(&sp->out);
      sp->state = SPS_IDLE;
      errno = saved_errno;
      return PROFILE_ERRIO;
    }
  }

  sp->timer.opt.interval_msec = opt->interval;
  sp->timer.opt.handler = sysprof_signal_handler;
  lj_profile_timer_start(&sp->timer);

  return PROFILE_SUCCESS;
}

int lj_sysprof_stop(lua_State *L)
{
  struct sysprof *sp = &sysprof;
  global_State *g = sp->g;
  struct lj_wbuf *out = &sp->out;

  if (SPS_IDLE == sp->state)
    return PROFILE_ERRRUN;
  else if (G(L) != g)
    return PROFILE_ERRUSE;

  lj_profile_timer_stop(&sp->timer);

  if (SPS_HALT == sp->state) {
    errno = sp->saved_errno;
    sp->state = SPS_IDLE;
    /* wbuf was terminated when error occured. */
    return PROFILE_ERRIO;
  }

  sp->state = SPS_IDLE;

  if (stream_is_needed(sp)) {
    int cb_status = 0;

    stream_epilogue(sp);
    lj_wbuf_flush(out);

    cb_status = sp->on_stop(sp->opt.ctx, out->buf);
    if (LJ_UNLIKELY(lj_wbuf_test_flag(out, STREAM_ERRIO | STREAM_STOP)) ||
        cb_status != 0) {
      errno = lj_wbuf_errno(out);
      lj_wbuf_terminate(out);
      return PROFILE_ERRIO;
    }

    lj_wbuf_terminate(out);
  }

  return PROFILE_SUCCESS;
}

int lj_sysprof_report(struct luam_Sysprof_Counters *counters)
{
  const struct sysprof *sp = &sysprof;
  if (sp->state != SPS_IDLE)
    return PROFILE_ERRUSE;
  memcpy(counters, &sp->counters, sizeof(sp->counters));
  return PROFILE_SUCCESS;
}

void lj_sysprof_add_proto(const struct GCproto *pt)
{
  struct sysprof *sp = &sysprof;

  if (sp->state != SPS_PROFILE || sp->opt.mode == LUAM_SYSPROF_DEFAULT)
    return;

  /*
  ** XXX: Avoid sampling during the symtab extension. That shouldn't have any
  ** significant effect on profile precision, but if it does, it's better to
  ** implement an async-safe queue for the symtab events.
  */
  sp->state = SPS_IDLE;
  lj_wbuf_addbyte(&sp->out, LJP_SYMTAB_LFUNC_EVENT);
  lj_symtab_dump_proto(&sp->out, pt);
  sp->state = SPS_PROFILE;
}

#if LJ_HASJIT
void lj_sysprof_add_trace(const struct GCtrace *tr)
{
  struct sysprof *sp = &sysprof;

  if (sp->state != SPS_PROFILE || sp->opt.mode == LUAM_SYSPROF_DEFAULT)
    return;

  /* See the comment about the sysprof state above. */
  sp->state = SPS_IDLE;
  lj_wbuf_addbyte(&sp->out, LJP_SYMTAB_TRACE_EVENT);
  lj_symtab_dump_trace(&sp->out, tr);
  sp->state = SPS_PROFILE;
}
#endif /* LJ_HASJIT */

#else /* LJ_HASSYSPROF */

int lj_sysprof_set_writer(luam_Sysprof_writer writer) {
  UNUSED(writer);
  return PROFILE_ERRUSE;
}

int lj_sysprof_set_on_stop(luam_Sysprof_on_stop on_stop) {
  UNUSED(on_stop);
  return PROFILE_ERRUSE;
}

int lj_sysprof_set_backtracer(luam_Sysprof_backtracer backtracer) {
  UNUSED(backtracer);
  return PROFILE_ERRUSE;
}

int lj_sysprof_start(lua_State *L, const struct luam_Sysprof_Options *opt)
{
  UNUSED(L);
  return PROFILE_ERRUSE;
}

int lj_sysprof_stop(lua_State *L)
{
  UNUSED(L);
  return PROFILE_ERRUSE;
}

int lj_sysprof_report(struct luam_Sysprof_Counters *counters)
{
  UNUSED(counters);
  return PROFILE_ERRUSE;
}

void lj_sysprof_add_proto(const struct GCproto *pt)
{
  UNUSED(pt);
}

#if LJ_HASJIT
void lj_sysprof_add_trace(const struct GCtrace *tr)
{
  UNUSED(tr);
}
#endif /* LJ_HASJIT */

#endif /* LJ_HASSYSPROF */

1	/*
2	** Implementation of sysprof - platform and Lua profiler.
3	*/
4
5	#define lj_sysprof_c
6	#define LUA_CORE
7
8	#include "lj_arch.h"
9	#include "lj_sysprof.h"
10
11	#if LJ_HASSYSPROF
12
13	#include "lj_obj.h"
14	#include "lj_debug.h"
15	#include "lj_dispatch.h"
16	#include "lj_frame.h"
17
18	#if LJ_HASJIT
19	#include "lj_jit.h"
20	#include "lj_trace.h"
21	#endif
22
23	#include "lj_wbuf.h"
24	#include "lj_profile_timer.h"
25	#include "lj_symtab.h"
26
27	#include <pthread.h>
28	#include <errno.h>
29	#include <execinfo.h>
30
31	/*
32	** Number of profiler frames we need to omit during stack
33	** unwinding.
34	** +------------------------+
35	** 0 \| default_backtrace_host \|
36	** +------------------------+
37	** 1 \| stream_backtrace_host \|
38	** +------------------------+
39	** 2 \| stream_{guest/host} \|
40	** +------------------------+
41	** 3 \| stream_event \|
42	** +------------------------+
43	** 4 \| sysprof_record_sample \|
44	** +------------------------+
45	** 5 \| sysprof_signal_handler \|
46	** +------------------------+
47	*/
48	#define SYSPROF_HANDLER_STACK_DEPTH 6
49	#define SYSPROF_BACKTRACE_FRAME_MAX 512
50
51	/* Check that vmstate fits in 4 bits (see streaming format) */
52	#define vmstfit4(st) ((st & ~(uint32_t)((1 << 4) - 1)) == 0)
53
54	enum sysprof_state {
55	/* Profiler is not running. */
56	SPS_IDLE,
57	/* Profiler is running. */
58	SPS_PROFILE,
59	/*
60	** Stopped in case of stopped or failed stream.
61	** Saved errno is set at luaM_sysprof_stop.
62	*/
63	SPS_HALT
64	};
65
66	struct sysprof {
67	global_State g; / Profiled VM. */
68	pthread_t thread; /* Profiled thread. */
69	volatile sig_atomic_t state; /* Internal state. */
70	struct lj_wbuf out; /* Output accumulator. */
71	struct luam_Sysprof_Counters counters; /* Profiling counters. */
72	struct luam_Sysprof_Options opt; /* Profiling options. */
73	luam_Sysprof_writer writer; /* Writer function for profile events. */
74	luam_Sysprof_on_stop on_stop; /* Callback on profiling stopping. */
75	luam_Sysprof_backtracer backtracer; /* Backtracing function for the host stack. */
76	lj_profile_timer timer; /* Profiling timer. */
77	int saved_errno; /* Saved errno when profiler failed. */
78	uint32_t lib_adds; /* Number of libs loaded. Monotonic. */
79	};
80	/*
81	** XXX: Only one VM can be profiled at a time.
82	*/
83
84	static struct sysprof sysprof = {0};
85
86	/* --- Stream ------------------------------------------------------------- */
87
88	static const uint8_t ljp_header[] = {'l', 'j', 'p', LJP_FORMAT_VERSION,
89	0x0, 0x0, 0x0};
90
91	static int stream_is_needed(struct sysprof *sp)	16✔
92	{
93	return sp->opt.mode != LUAM_SYSPROF_DEFAULT;	16✔
94	}
95
96	static int is_unconfigured(struct sysprof *sp)	695✔
97	{
98	return sp->backtracer == NULL \|\| sp->on_stop == NULL \|\| sp->writer == NULL;	233✔
99	}
100
101	static void stream_prologue(struct sysprof *sp)	2✔
102	{
103	lj_symtab_dump(&sp->out, sp->g, &sp->lib_adds);	2✔
104	lj_wbuf_addn(&sp->out, ljp_header, sizeof(ljp_header));	2✔
105	}	2✔
106
107	static void stream_epilogue(struct sysprof *sp)	2✔
108	{
109	lj_wbuf_addbyte(&sp->out, LJP_EPILOGUE_BYTE);	2✔
110	}
111
112	static void stream_lfunc(struct lj_wbuf buf, const GCfunc func)
113	{
114	lj_assertX(isluafunc(func), "bad lua function in sysprof stream");
115	const GCproto *pt = funcproto(func);
116	lj_assertX(pt != NULL, "bad lua function prototype in sysprof stream");
117	lj_wbuf_addbyte(buf, LJP_FRAME_LFUNC);
118	lj_wbuf_addu64(buf, (uintptr_t)pt);
119	lj_wbuf_addu64(buf, (uint64_t)pt->firstline);
120	}
121
122	static void stream_cfunc(struct lj_wbuf buf, const GCfunc func)	×
123	{
124	lj_assertX(iscfunc(func), "bad C function in sysprof stream");	×
125	lj_wbuf_addbyte(buf, LJP_FRAME_CFUNC);	×
126	lj_wbuf_addu64(buf, (uintptr_t)func->c.f);	×
127	}	×
128
129	static void stream_ffunc(struct lj_wbuf buf, const GCfunc func)	×
130	{
131	lj_assertX(isffunc(func), "bad fast function in sysprof stream");	×
132	lj_wbuf_addbyte(buf, LJP_FRAME_FFUNC);	×
133	lj_wbuf_addu64(buf, func->c.ffid);	×
134	}	×
135
136	static void stream_frame_lua(struct lj_wbuf buf, const cTValue frame)	×
137	{
138	const GCfunc *func = frame_func(frame);	×
139	lj_assertX(func != NULL, "bad function in sysprof stream");	×
140	if (isluafunc(func))	×
141	stream_lfunc(buf, func);	×
142	else if (isffunc(func))	×
143	stream_ffunc(buf, func);	×
144	else if (iscfunc(func))	×
145	stream_cfunc(buf, func);	×
146	else
147	/* Unreachable. */
148	lj_assertX(0, "bad function type in sysprof stream");	×
149	}	×
150
151	static void stream_backtrace_lua(struct sysprof *sp)	×
152	{
153	global_State *g = sp->g;	×
154	struct lj_wbuf *buf = &sp->out;	×
155	cTValue top_frame = NULL, frame = NULL, *bot = NULL;	×
156	lua_State *L = NULL;	×
157
158	lj_assertX(g != NULL, "uninitialized global state in sysprof state");	×
159	L = gco2th(gcref(g->cur_L));	×
160	lj_assertG(L != NULL, "uninitialized Lua state in sysprof state");	×
161
162	top_frame = g->top_frame - 1; //(1 + LJ_FR2)	×
163
164	bot = tvref(L->stack) + LJ_FR2;	×
165	/* Traverse frames backwards */
166	for (frame = top_frame; frame > bot; frame = frame_prev(frame)) {	×
167	if (frame_gc(frame) == obj2gco(L) \|\| frame_isvarg(frame))	×
168	continue; /* Skip dummy frames. See lj_err_optype_call(). */	×
169	stream_frame_lua(buf, frame);	×
170	}
171
172	lj_wbuf_addbyte(buf, LJP_FRAME_LUA_LAST);	×
173	}	×
174
175	static void stream_frame_host(int frame_no, void addr)	8✔
176	{
177	struct sysprof *sp = &sysprof;	8✔
178	/*
179	** We don't want the profiler stack to be streamed, as it will
180	** burden the profile with unnecessary information.
181	*/
182	if (LJ_UNLIKELY(frame_no <= SYSPROF_HANDLER_STACK_DEPTH))	8✔
183	return addr;
184	else if (LJ_UNLIKELY(sp->opt.mode == LUAM_SYSPROF_LEAF &&	1✔
185	frame_no > SYSPROF_HANDLER_STACK_DEPTH))
186	return NULL;
187
188	lj_wbuf_addu64(&sp->out, (uintptr_t)addr);	1✔
189	return addr;	1✔
190	}
191
192	static void default_backtrace_host(void (writer)(int frame_no, void addr))	2✔
193	{
194	static void *backtrace_buf[SYSPROF_BACKTRACE_FRAME_MAX] = {};	2✔
195
196	struct sysprof *sp = &sysprof;	2✔
197	int max_depth = sp->opt.mode == LUAM_SYSPROF_LEAF	4✔
198	? SYSPROF_HANDLER_STACK_DEPTH + 1
199	: SYSPROF_BACKTRACE_FRAME_MAX;	2✔
200	const int depth = backtrace(backtrace_buf, max_depth);	2✔
201	int level;	2✔
202
203	lj_assertX(depth <= max_depth, "depth of C stack is too big");	2✔
204	for (level = SYSPROF_HANDLER_STACK_DEPTH; level < depth; ++level) {	12✔
205	if (!writer(level - SYSPROF_HANDLER_STACK_DEPTH + 1, backtrace_buf[level]))	8✔
206	return;
207	}
208	}
209
210	static void stream_backtrace_host(struct sysprof *sp)	2✔
211	{
212	lj_assertX(sp->backtracer != NULL, "uninitialized sysprof backtracer");	2✔
213	sp->backtracer(stream_frame_host);	2✔
214	lj_wbuf_addu64(&sp->out, (uintptr_t)LJP_FRAME_HOST_LAST);	2✔
215	}
216
217	#if LJ_HASJIT
218	static void stream_trace(struct sysprof *sp, uint32_t vmstate)	×
219	{
220	lj_wbuf_addbyte(&sp->out, (uint8_t)vmstate);	×
221	struct lj_wbuf *out = &sp->out;	×
222	uint32_t traceno = sp->g->vmstate;	×
223	jit_State *J = G2J(sp->g);	×
224	GCtrace *trace = traceref(J, traceno);	×
225
226	GCproto *startpt = gco2pt(gcref(trace->startpt));	×
227
228	lj_wbuf_addu64(out, traceno);	×
229	lj_wbuf_addu64(out, (uintptr_t)startpt);	×
230	lj_wbuf_addu64(out, startpt->firstline);	×
231	}	×
232	#endif
233
234	static void stream_guest(struct sysprof *sp, uint32_t vmstate)	×
235	{
236	lj_wbuf_addbyte(&sp->out, (uint8_t)vmstate);	×
237	stream_backtrace_lua(sp);	×
238	stream_backtrace_host(sp);	×
239	}	×
240
241	static void stream_host(struct sysprof *sp, uint32_t vmstate)	2✔
242	{
243	struct lua_State *L = gco2th(gcref(sp->g->cur_L));	2✔
244	lj_symtab_dump_newc(&sp->lib_adds, &sp->out, LJP_SYMTAB_CFUNC_EVENT, L);	2✔
245	lj_wbuf_addbyte(&sp->out, (uint8_t)vmstate);	2✔
246	stream_backtrace_host(sp);	2✔
247	}	2✔
248
249	typedef void (event_streamer)(struct sysprof sp, uint32_t vmstate);
250
251	static event_streamer event_streamers[] = {
252	/* XXX: order is important */
253	stream_host, /* LJ_VMST_INTERP */
254	stream_guest, /* LJ_VMST_LFUNC */
255	stream_guest, /* LJ_VMST_FFUNC */
256	stream_guest, /* LJ_VMST_CFUNC */
257	stream_host, /* LJ_VMST_GC */
258	stream_host, /* LJ_VMST_EXIT */
259	stream_host, /* LJ_VMST_RECORD */
260	stream_host, /* LJ_VMST_OPT */
261	stream_host, /* LJ_VMST_ASM */
262	#if LJ_HASJIT
263	stream_trace /* LJ_VMST_TRACE */
264	#endif
265	};
266
267	static void stream_event(struct sysprof *sp, uint32_t vmstate)
268	{
269	event_streamer stream = NULL;
270
271	lj_assertX(vmstfit4(vmstate), "vmstate don't fit in 4 bits");
272	stream = event_streamers[vmstate];
273	lj_assertX(stream != NULL, "uninitialized sysprof stream");
274	stream(sp, vmstate);
275	}
276
277	/* -- Signal handler ------------------------------------------------------ */
278
279	static void sysprof_record_sample(struct sysprof sp, siginfo_t info)
280	{
281	global_State *g = sp->g;
282	uint32_t _vmstate = ~(uint32_t)(g->vmstate);
283	uint32_t vmstate = _vmstate < LJ_VMST_TRACE ? _vmstate : LJ_VMST_TRACE;
284
285	lj_assertX(pthread_self() == sp->thread,
286	"bad thread during sysprof record sample");
287
288	/* Caveat: order of counters must match vmstate order in <lj_obj.h>. */
289	((uint64_t *)&sp->counters)[vmstate]++;
290
291	sp->counters.samples++;
292
293	if (!stream_is_needed(sp))
294	return;
295
296	stream_event(sp, vmstate);
297	if (LJ_UNLIKELY(lj_wbuf_test_flag(&sp->out, STREAM_ERRIO\|STREAM_STOP))) {
298	sp->saved_errno = lj_wbuf_errno(&sp->out);
299	lj_wbuf_terminate(&sp->out);
300	sp->state = SPS_HALT;
301	}
302	}
303
304	static void sysprof_signal_handler(int sig, siginfo_t info, void ctx)	3✔
305	{
306	struct sysprof *sp = &sysprof;	3✔
307	UNUSED(sig);	3✔
308	UNUSED(ctx);	3✔
309
310	switch (sp->state) {	3✔
311	case SPS_PROFILE:	3✔
312	sysprof_record_sample(sp, info);	3✔
313	break;	3✔
314
315	case SPS_IDLE:
316	case SPS_HALT:
317	/* noop */
318	break;
319
320	default:
321	lj_assertX(0, "bad sysprof profiler state");
322	break;
323	}
324	}	3✔
325
326	/* -- Internal ------------------------------------------------------------ */
327
328	static int sysprof_validate(struct sysprof *sp,	13✔
329	const struct luam_Sysprof_Options *opt)
330	{
331	switch (sp->state) {	13✔
332	case SPS_IDLE:	11✔
333	if (opt->mode > LUAM_SYSPROF_CALLGRAPH) {	11✔
334	return PROFILE_ERRUSE;
335	} else if (opt->mode != LUAM_SYSPROF_DEFAULT &&	10✔
336	(opt->buf == NULL \|\| opt->len == 0 \|\| is_unconfigured(sp))) {	3✔
337	return PROFILE_ERRUSE;
338	} else if (opt->interval == 0) {	9✔
339	return PROFILE_ERRUSE;	1✔
340	}
341	break;
342
343	case SPS_PROFILE:
344	case SPS_HALT:
345	return PROFILE_ERRRUN;
346
347	default:
348	lj_assertX(0, "bad sysprof profiler state");
349	break;
350	}
351
352	return PROFILE_SUCCESS;
353	}
354
355	static int sysprof_init(struct sysprof sp, lua_State L,
356	const struct luam_Sysprof_Options *opt)
357	{
358	const int status = sysprof_validate(sp, opt);
359	if (PROFILE_SUCCESS != status)
360	return status;
361
362	/* Copy validated options to sysprof state. */
363	memcpy(&sp->opt, opt, sizeof(sp->opt));
364
365	/* Init general fields. */
366	sp->g = G(L);
367	sp->thread = pthread_self();
368
369	/* Reset counters. */
370	memset(&sp->counters, 0, sizeof(sp->counters));
371
372	/* Reset saved errno. */
373	sp->saved_errno = 0;
374
375	if (stream_is_needed(sp))
376	lj_wbuf_init(&sp->out, sp->writer, opt->ctx, opt->buf, opt->len);
377
378	return PROFILE_SUCCESS;
379	}
380
381	/* -- Public profiling API ------------------------------------------------ */
382
383	int lj_sysprof_set_writer(luam_Sysprof_writer writer) {	231✔
384	struct sysprof *sp = &sysprof;	231✔
385
386	if (sp->state != SPS_IDLE \|\| writer == NULL)	231✔
387	return PROFILE_ERRUSE;
388
389	sp->writer = writer;	231✔
390	if (!is_unconfigured(sp)) {	231✔
391	sp->state = SPS_IDLE;	×
392	}
393	return PROFILE_SUCCESS;
394	}
395
396	int lj_sysprof_set_on_stop(luam_Sysprof_on_stop on_stop) {	231✔
397	struct sysprof *sp = &sysprof;	231✔
398
399	if (sp->state != SPS_IDLE \|\| on_stop == NULL)	231✔
400	return PROFILE_ERRUSE;
401
402	sp->on_stop = on_stop;	231✔
403	if (!is_unconfigured(sp)) {	231✔
404	sp->state = SPS_IDLE;	×
405	}
406	return PROFILE_SUCCESS;
407	}
408
409	int lj_sysprof_set_backtracer(luam_Sysprof_backtracer backtracer) {	231✔
410	struct sysprof *sp = &sysprof;	231✔
411
412	if (sp->state != SPS_IDLE)	231✔
413	return PROFILE_ERRUSE;
414	if (backtracer == NULL) {	231✔
415	sp->backtracer = default_backtrace_host;	231✔
416	/*
417	** XXX: `backtrace` is not signal-safe, according to man,
418	** because it is lazy loaded on the first call, which triggers
419	** allocations. We need to call `backtrace` before starting profiling
420	** to avoid lazy loading.
421	*/
422	void *dummy = NULL;	231✔
423	backtrace(&dummy, 1);	231✔
424	}
425	else {
426	sp->backtracer = backtracer;	×
427	}
428	if (!is_unconfigured(sp)) {	231✔
429	sp->state = SPS_IDLE;	231✔
430	}
431	return PROFILE_SUCCESS;
432	}
433
434	int lj_sysprof_start(lua_State L, const struct luam_Sysprof_Options opt)	13✔
435	{
436	struct sysprof *sp = &sysprof;	13✔
437
438	int status = sysprof_init(sp, L, opt);	13✔
439	if (PROFILE_SUCCESS != status) {	13✔
440	if (NULL != sp->on_stop) {	5✔
441	/*
442	** Initialization may fail in case of unconfigured sysprof,
443	** so we cannot guarantee cleaning up resources in this case.
444	*/
445	sp->on_stop(opt->ctx, opt->buf);	5✔
446	}
447	return status;	5✔
448	}
449
450	sp->state = SPS_PROFILE;	8✔
451
452	if (stream_is_needed(sp)) {	8✔
453	stream_prologue(sp);	2✔
454	if (LJ_UNLIKELY(lj_wbuf_test_flag(&sp->out, STREAM_ERRIO\|STREAM_STOP))) {	2✔
455	/* on_stop call may change errno value. */
456	const int saved_errno = lj_wbuf_errno(&sp->out);	×
457	/* Ignore possible errors. mp->out.buf may be NULL here. */
458	sp->on_stop(opt->ctx, sp->out.buf);	×
459	lj_wbuf_terminate(&sp->out);	×
460	sp->state = SPS_IDLE;	×
461	errno = saved_errno;	×
462	return PROFILE_ERRIO;	×
463	}
464	}
465
466	sp->timer.opt.interval_msec = opt->interval;	8✔
467	sp->timer.opt.handler = sysprof_signal_handler;	8✔
468	lj_profile_timer_start(&sp->timer);	8✔
469
470	return PROFILE_SUCCESS;	8✔
471	}
472
473	int lj_sysprof_stop(lua_State *L)	239✔
474	{
475	struct sysprof *sp = &sysprof;	239✔
476	global_State *g = sp->g;	239✔
477	struct lj_wbuf *out = &sp->out;	239✔
478
479	if (SPS_IDLE == sp->state)	239✔
480	return PROFILE_ERRRUN;
481	else if (G(L) != g)	8✔
482	return PROFILE_ERRUSE;
483
484	lj_profile_timer_stop(&sp->timer);	8✔
485
486	if (SPS_HALT == sp->state) {	8✔
487	errno = sp->saved_errno;	×
488	sp->state = SPS_IDLE;	×
489	/* wbuf was terminated when error occured. */
490	return PROFILE_ERRIO;	×
491	}
492
493	sp->state = SPS_IDLE;	8✔
494
495	if (stream_is_needed(sp)) {	8✔
496	int cb_status = 0;	2✔
497
498	stream_epilogue(sp);	2✔
499	lj_wbuf_flush(out);	2✔
500
501	cb_status = sp->on_stop(sp->opt.ctx, out->buf);	2✔
502	if (LJ_UNLIKELY(lj_wbuf_test_flag(out, STREAM_ERRIO \| STREAM_STOP)) \|\|	2✔
503	cb_status != 0) {
504	errno = lj_wbuf_errno(out);	×
505	lj_wbuf_terminate(out);	×
506	return PROFILE_ERRIO;	×
507	}
508
509	lj_wbuf_terminate(out);	2✔
510	}
511
512	return PROFILE_SUCCESS;
513	}
514
515	int lj_sysprof_report(struct luam_Sysprof_Counters *counters)	3✔
516	{
517	const struct sysprof *sp = &sysprof;	3✔
518	if (sp->state != SPS_IDLE)	3✔
519	return PROFILE_ERRUSE;
520	memcpy(counters, &sp->counters, sizeof(sp->counters));	3✔
521	return PROFILE_SUCCESS;	3✔
522	}
523
524	void lj_sysprof_add_proto(const struct GCproto *pt)	52,695✔
525	{
526	struct sysprof *sp = &sysprof;	52,695✔
527
528	if (sp->state != SPS_PROFILE \|\| sp->opt.mode == LUAM_SYSPROF_DEFAULT)	52,695✔
529	return;
530
531	/*
532	** XXX: Avoid sampling during the symtab extension. That shouldn't have any
533	** significant effect on profile precision, but if it does, it's better to
534	** implement an async-safe queue for the symtab events.
535	*/
536	sp->state = SPS_IDLE;	×
537	lj_wbuf_addbyte(&sp->out, LJP_SYMTAB_LFUNC_EVENT);	×
538	lj_symtab_dump_proto(&sp->out, pt);	×
539	sp->state = SPS_PROFILE;	×
540	}
541
542	#if LJ_HASJIT
543	void lj_sysprof_add_trace(const struct GCtrace *tr)	2,303✔
544	{
545	struct sysprof *sp = &sysprof;	2,303✔
546
547	if (sp->state != SPS_PROFILE \|\| sp->opt.mode == LUAM_SYSPROF_DEFAULT)	2,303✔
548	return;
549
550	/* See the comment about the sysprof state above. */
551	sp->state = SPS_IDLE;	×
552	lj_wbuf_addbyte(&sp->out, LJP_SYMTAB_TRACE_EVENT);	×
553	lj_symtab_dump_trace(&sp->out, tr);	×
554	sp->state = SPS_PROFILE;	×
555	}
556	#endif /* LJ_HASJIT */
557
558	#else /* LJ_HASSYSPROF */
559
560	int lj_sysprof_set_writer(luam_Sysprof_writer writer) {
561	UNUSED(writer);
562	return PROFILE_ERRUSE;
563	}
564
565	int lj_sysprof_set_on_stop(luam_Sysprof_on_stop on_stop) {
566	UNUSED(on_stop);
567	return PROFILE_ERRUSE;
568	}
569
570	int lj_sysprof_set_backtracer(luam_Sysprof_backtracer backtracer) {
571	UNUSED(backtracer);
572	return PROFILE_ERRUSE;
573	}
574
575	int lj_sysprof_start(lua_State L, const struct luam_Sysprof_Options opt)
576	{
577	UNUSED(L);
578	return PROFILE_ERRUSE;
579	}
580
581	int lj_sysprof_stop(lua_State *L)
582	{
583	UNUSED(L);
584	return PROFILE_ERRUSE;
585	}
586
587	int lj_sysprof_report(struct luam_Sysprof_Counters *counters)
588	{
589	UNUSED(counters);
590	return PROFILE_ERRUSE;
591	}
592
593	void lj_sysprof_add_proto(const struct GCproto *pt)
594	{
595	UNUSED(pt);
596	}
597
598	#if LJ_HASJIT
599	void lj_sysprof_add_trace(const struct GCtrace *tr)
600	{
601	UNUSED(tr);
602	}
603	#endif /* LJ_HASJIT */
604
605	#endif /* LJ_HASSYSPROF */

tarantool / luajit / 6122165118

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous