Exemple #1
0
static VALUE stop_stat_tracing() {
  if (logger->hooks[0] != 0) {
    rb_tracepoint_disable(logger->hooks[0]);
    rb_tracepoint_disable(logger->hooks[1]);
    rb_tracepoint_disable(logger->hooks[2]);
  }

  if (logger->newobj_trace) {
    rb_tracepoint_disable(logger->newobj_trace);
    rb_tracepoint_disable(logger->freeobj_trace);
  }
  logger->enabled = Qfalse;
  return Qnil;
}
Exemple #2
0
static VALUE
stackprof_stop(VALUE self)
{
    struct sigaction sa;
    struct itimerval timer;

    if (!_stackprof.running)
	return Qfalse;
    _stackprof.running = 0;

    if (_stackprof.mode == sym_object) {
	rb_tracepoint_disable(objtracer);
    } else if (_stackprof.mode == sym_wall || _stackprof.mode == sym_cpu) {
	memset(&timer, 0, sizeof(timer));
	setitimer(_stackprof.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);

	sa.sa_handler = SIG_IGN;
	sa.sa_flags = SA_RESTART;
	sigemptyset(&sa.sa_mask);
	sigaction(_stackprof.mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);
    } else if (_stackprof.mode == sym_custom) {
	/* sampled manually */
    } else {
	rb_raise(rb_eArgError, "unknown profiler mode");
    }

    return Qtrue;
}
Exemple #3
0
static void
clear_tracepoints(VALUE self)
{
  int i;

  UNUSED(self);

  for (i = RARRAY_LENINT(tracepoints) - 1; i >= 0; i--)
    rb_tracepoint_disable(rb_ary_entry(tracepoints, i));
}
/**
 * rb_disable_traces
 * This is implmenetation of Tracer#disable_traces methods. It disables
 * Tracer#file_tracepoint, Tracer#fiber_tracepoint, return event tracing, and
 * line event tracing for all threads.
 */
static VALUE
rb_disable_traces(VALUE self)
{
    VALUE file_tracepoint;
    VALUE fiber_tracepoint;
    VALUE threads;
    VALUE *c_threads;
    int c_threads_len;
    VALUE thread;
    int i;
    ID alive_q_id;
    ID list_id;

    CONST_ID(alive_q_id, "alive?");
    CONST_ID(list_id, "list");

    file_tracepoint = rb_iv_get(self, "@file_tracepoint");
    threads = rb_funcall(rb_cThread, list_id, 0);
    c_threads_len = RARRAY_LEN(threads);
    c_threads = RARRAY_PTR(threads);
    UNUSED(fiber_tracepoint);

    if (RTEST(file_tracepoint) && RTEST(rb_tracepoint_enabled_p(file_tracepoint)))
        rb_tracepoint_disable(file_tracepoint);

#ifdef RUBY_EVENT_FIBER_SWITCH
    fiber_tracepoint= rb_iv_get(self, "@fiber_tracepoint");
    if (RTEST(fiber_tracepoint) && RTEST(rb_tracepoint_enabled_p(fiber_tracepoint)))
        rb_tracepoint_disable(fiber_tracepoint);
#endif

    for (i = 0; i < c_threads_len; i++) {
        thread = c_threads[i];
        if (RTEST(rb_funcall(thread, alive_q_id, 0))) {
            disable_line_trace_for_thread(thread);
            disable_return_trace_for_thread(thread);
        }
    }

    return Qnil;
}
Exemple #5
0
/*
 * call-seq:
 *	trace.disable		-> true or false
 *	trace.disable { block } -> obj
 *
 * Deactivates the trace
 *
 * Return true if trace was enabled.
 * Return false if trace was disabled.
 *
 *	trace.enabled?	#=> true
 *	trace.disable	#=> false (previous status)
 *	trace.enabled?	#=> false
 *	trace.disable	#=> false
 *
 * If a block is given, the trace will only be disable within the scope of the
 * block.
 *
 *	trace.enabled?
 *	#=> true
 *
 *	trace.disable do
 *	    trace.enabled?
 *	    # only disabled for this block
 *	end
 *
 *	trace.enabled?
 *	#=> true
 *
 * Note: You cannot access event hooks within the block.
 *
 *	trace.disable { p tp.lineno }
 *	#=> RuntimeError: access from outside
 */
static VALUE
tracepoint_disable_m(VALUE tpval)
{
    rb_tp_t *tp = tpptr(tpval);
    int previous_tracing = tp->tracing;
    rb_tracepoint_disable(tpval);

    if (rb_block_given_p()) {
	return rb_ensure(rb_yield, Qnil,
			 previous_tracing ? rb_tracepoint_enable : rb_tracepoint_disable,
			 tpval);
    }
    else {
	return previous_tracing ? Qtrue : Qfalse;
    }
}