google-cloud-debugger 0.24.0

data/ext/google/cloud/debugger/debugger_c/tracer.c

@@ -0,0 +1,478 @@
+/*
+    Copyright 2017 Google Inc. All rights reserved.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+#include "tracer.h"
+
+/**
+ *  hash_get_keys_callback
+ *  Helper callback function for hash_get_keys.
+ */
+static int
+hash_get_keys_callback(VALUE key, VALUE val, VALUE key_ary)
+{
+    rb_ary_push(key_ary, key);
+
+    return ST_CONTINUE;
+}
+
+/**
+ * hash_get_keys
+ * Helper function to return an array of all the keys of a given Ruby array
+ */
+static VALUE
+hash_get_keys(VALUE hash)
+{
+    VALUE key_ary;
+
+    if(!RB_TYPE_P(hash, T_HASH)) {
+        return Qnil;
+    }
+
+    key_ary = rb_ary_new();
+
+    rb_hash_foreach(hash, hash_get_keys_callback, key_ary);
+
+    return key_ary;
+}
+
+/**
+ *  match_breakpoints_files
+ *  Check the Tracer#breakpoints_cache if any breakpoints match the given
+ *  tracepoint_path. Return 1 if found. Otherwise 0;
+ */
+static VALUE
+match_breakpoints_files(VALUE self, VALUE tracepoint_path)
+{
+    int i;
+    char *c_tracepoint_path = rb_string_value_cstr(&tracepoint_path);
+
+    VALUE path_breakpoints_hash = rb_iv_get(self, "@breakpoints_cache");
+    VALUE breakpoints_paths = hash_get_keys(path_breakpoints_hash);
+    VALUE *c_breakpoints_paths = RARRAY_PTR(breakpoints_paths);
+    int breakpoints_paths_len = RARRAY_LEN(breakpoints_paths);
+
+    for (i = 0; i < breakpoints_paths_len; i++) {
+        VALUE breakpoint_path = c_breakpoints_paths[i];
+        char *c_breakpoint_path = rb_string_value_cstr(&breakpoint_path);
+
+        if (strcmp(c_tracepoint_path, c_breakpoint_path) == 0) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static VALUE
+disable_line_trace_for_thread(VALUE thread);
+
+/**
+ *  match_breakpoints
+ *  Check the Tracer#breakpoints_cache for any matching breakpoints of given
+ *  file path and line number.
+ *
+ *  Return a Ruby array of breakpoints found. Qtrue if no match found, but this
+ *  file contains at least one breakpoint. Qnil if event triggered in a file
+ *  that doesn't contain any breakpoints.
+ */
+static VALUE
+match_breakpoints(VALUE self, const char *c_trace_path, int c_trace_lineno)
+{
+    int i, j;
+    VALUE path_breakpoints_hash = rb_iv_get(self, "@breakpoints_cache");
+    VALUE breakpoints_paths = hash_get_keys(path_breakpoints_hash);
+    VALUE *c_breakpoints_paths = RARRAY_PTR(breakpoints_paths);
+    int breakpoints_paths_len = RARRAY_LEN(breakpoints_paths);
+    VALUE path_match = Qnil;
+
+    // Check the file paths of @breakpoints_cache
+    for (i = 0; i < breakpoints_paths_len; i++) {
+        VALUE breakpoint_path = c_breakpoints_paths[i];
+        char *c_breakpoint_path = rb_string_value_cstr(&breakpoint_path);
+
+        // Found matching file path, keep going and check for the line numbers
+        if (strcmp(c_trace_path, c_breakpoint_path) == 0) {
+            VALUE line_breakpoint_hash = rb_hash_aref(path_breakpoints_hash, breakpoint_path);
+            VALUE breakpoints_lines = hash_get_keys(line_breakpoint_hash);
+            VALUE *c_breakpoints_lines = RARRAY_PTR(breakpoints_lines);
+            int breakpoints_lines_len = RARRAY_LEN(breakpoints_lines);
+            path_match = Qtrue;
+
+            // Found matching breakpoints. Return the cached breakpoints array
+            for (j = 0; j < breakpoints_lines_len; j++) {
+                VALUE breakpoint_lineno = c_breakpoints_lines[j];
+                int c_breakpoint_lineno = NUM2INT(breakpoint_lineno);
+
+                if (c_trace_lineno == c_breakpoint_lineno) {
+                    return rb_hash_aref(line_breakpoint_hash, breakpoint_lineno);
+                }
+            }
+        }
+    }
+
+    return path_match;
+}
+
+/**
+ *  line_trace_callback
+ *  Callback function for thread line event tracing. It checks tracer#breakpoint_cache
+ *  for any breakpoints trigger on current line called. Then trigger evaluation
+ *  procedure if found matching breakpoints. It also skip breakpoints that are
+ *  already marked completed.
+ */
+static void
+line_trace_callback(rb_event_flag_t event, VALUE data, VALUE obj, ID mid, VALUE klass)
+{
+    VALUE self = data;
+    const char *c_trace_path = rb_sourcefile();
+    int c_trace_lineno = rb_sourceline();
+    VALUE trace_binding;
+    VALUE call_stack_bindings;
+
+    int i;
+    VALUE matching_result = match_breakpoints(self, c_trace_path, c_trace_lineno);
+    VALUE *c_matching_breakpoints;
+    VALUE matching_breakpoint;
+    int matching_breakpoints_len;
+
+    // If matching result isn't an array, it means we're in completely wrong file,
+    // or not on the right line. Turn line tracing off if we're in wrong file.
+    if (!RB_TYPE_P(matching_result, T_ARRAY)) {
+        if (!RTEST(matching_result)) {
+            disable_line_trace_for_thread(Qnil);
+        }
+        return;
+    }
+
+    c_matching_breakpoints = RARRAY_PTR(matching_result);
+    matching_breakpoints_len = RARRAY_LEN(matching_result);
+    trace_binding = rb_binding_new();
+    call_stack_bindings = rb_funcall(trace_binding, rb_intern("callers"), 0);
+    rb_ary_pop(call_stack_bindings);
+
+    // Evaluate each of the matching breakpoint
+    for (i = 0; i < matching_breakpoints_len; i++) {
+        matching_breakpoint = c_matching_breakpoints[i];
+        rb_funcall(self, rb_intern("eval_breakpoint"), 2, matching_breakpoint, call_stack_bindings);
+    }
+
+    return;
+}
+
+/**
+ *  disable_line_trace_for_thread
+ *  Turn off line event trace hook for a given thread. If no thread is given, it
+ *  turns off line event trace hook in current thread. It only takes action if
+ *  the thread has a thread variable "gcloud_line_trace_set" that's true.
+ */
+static VALUE
+disable_line_trace_for_thread(VALUE thread)
+{
+    VALUE thread_variables_hash;
+    VALUE line_trace_set;
+
+    if (!RTEST(thread)) {
+        thread = rb_thread_current();
+    }
+    thread_variables_hash = rb_ivar_get(thread, rb_intern("locals"));
+    line_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"));
+
+    if (RTEST(line_trace_set)) {
+        rb_thread_remove_event_hook(thread, line_trace_callback);
+        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"), Qfalse);
+    }
+
+    return Qnil;
+}
+
+/**
+ * enable_line_trace_for_thread
+ * Turn on line even trace for current thread. Also set a flag
+ * "gcloud_line_trace_set" to Qtrue in current thread's thread variable.
+ */
+static VALUE
+enable_line_trace_for_thread(VALUE self)
+{
+    VALUE current_thread = rb_thread_current();
+    VALUE thread_variables_hash = rb_ivar_get(current_thread, rb_intern("locals"));
+    VALUE line_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"));
+
+    if (!RTEST(line_trace_set)) {
+        rb_thread_add_event_hook(current_thread, line_trace_callback, RUBY_EVENT_LINE, self);
+        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"), Qtrue);
+    }
+
+    return Qnil;
+}
+
+/**
+ * return_trace_callback
+ * Callback function for tracer#return_tracepoint. It gets called on
+ * RUBY_EVENT_END, RUBY_EVENT_RETURN, RUBY_EVENT_C_RETURN, and
+ * RUBY_EVENT_B_RETURN events. It keeps line tracing consistent when Ruby
+ * program counter interleaves files. Everytime called, it checks caller stack
+ * frame's file path, if it matches any of the breakpoints, it turns line
+ * event tracing back on. It also decrements tracer#return_tracepoint_counter
+ * everytime called. When the counter is at 0, it disables itself, which should
+ * be the same stack frame that the return_tracepoint is turned on.
+ */
+static void
+return_trace_callback(void *data, rb_trace_arg_t *trace_arg)
+{
+    VALUE match_found;
+    VALUE self = (VALUE) data;
+    VALUE caller_locations = rb_funcall(rb_mKernel, rb_intern("caller_locations"), 2, INT2NUM(0), INT2NUM(1));
+    VALUE *c_caller_locations;
+    VALUE caller_location;
+    VALUE caller_path;
+
+    if(!RTEST(caller_locations)) {
+        return;
+    }
+
+    c_caller_locations = RARRAY_PTR(caller_locations);
+    caller_location = c_caller_locations[0];
+    caller_path = rb_funcall(caller_location, rb_intern("absolute_path"), 0);
+
+    if(!RTEST(caller_path)) {
+        return;
+    }
+
+    match_found = match_breakpoints_files(self, caller_path);
+
+    if (match_found) {
+        enable_line_trace_for_thread(self);
+    }
+
+    return;
+}
+
+/**
+ *  disable_return_trace_for_thread
+ *  Turn off return events trace hook for a given thread. If no thread is given, it
+ *  turns off line event trace hook in current thread. It only takes action if
+ *  the thread has a thread variable "gcloud_return_trace_set" that's true.
+ */
+static VALUE
+disable_return_trace_for_thread(VALUE thread)
+{
+    VALUE thread_variables_hash;
+    VALUE return_trace_set;
+
+    if (!RTEST(thread)) {
+        thread = rb_thread_current();
+    }
+    thread_variables_hash = rb_ivar_get(thread, rb_intern("locals"));
+    return_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"));
+
+    if (RTEST(return_trace_set)) {
+        rb_thread_remove_event_hook(thread, (rb_event_hook_func_t)return_trace_callback);
+        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"), Qfalse);
+    }
+
+    return Qnil;
+}
+
+/**
+ * enable_return_trace_for_thread
+ * Turn on return events trace for current thread. Also set a flag
+ * "gcloud_return_trace_set" to Qtrue in current thread's thread variable.
+ */
+static VALUE
+enable_return_trace_for_thread(VALUE self)
+{
+    VALUE current_thread = rb_thread_current();
+    VALUE thread_variables_hash = rb_ivar_get(current_thread, rb_intern("locals"));
+    VALUE return_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"));
+
+    if (!RTEST(return_trace_set)) {
+        int return_tracepoint_event = RUBY_EVENT_END | RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN | RUBY_EVENT_B_RETURN;
+        rb_thread_add_event_hook2(current_thread, (rb_event_hook_func_t)return_trace_callback, return_tracepoint_event, self, RUBY_EVENT_HOOK_FLAG_RAW_ARG | RUBY_EVENT_HOOK_FLAG_SAFE);
+        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"), Qtrue);
+    }
+
+    return Qnil;
+}
+
+/**
+ * file_tracepoint_callback
+ * Callback function for tracer#file_tracepoint. It gets called on
+ * RUBY_EVENT_CLASS, RUBY_EVENT_CALL, RUBY_EVENT_C_CALL, and RUBY_EVENT_B_CALL
+ * events. It check if any breakpoints matches current file the VM program counter
+ * is in, and turn on line event tracing for that thread. Otherwise turn off
+ * line tracing if in wrong file. The first time it turns on line even tracing,
+ * it also turns on tracer#return_tracepoint to maintain line tracing
+ * consistency when file execution interleaves. If return_tracepoint is already
+ * on, it increments tracer#return_tracepoint_counter.
+ */
+static void
+file_tracepoint_callback(VALUE tracepoint, void *data)
+{
+    VALUE self = (VALUE) data;
+    rb_trace_arg_t *tracepoint_arg = rb_tracearg_from_tracepoint(tracepoint);
+    VALUE tracepoint_path = rb_tracearg_path(tracepoint_arg);
+    VALUE match_found;
+
+    if (!RB_TYPE_P(tracepoint_path, T_STRING))
+        return;
+
+    match_found = match_breakpoints_files(self, tracepoint_path);
+
+    if (match_found) {
+        enable_line_trace_for_thread(self);
+        enable_return_trace_for_thread(self);
+    }
+    else {
+        disable_line_trace_for_thread(Qnil);
+    }
+
+    return;
+}
+
+#ifdef RUBY_EVENT_FIBER_SWITCH
+static void
+fiber_tracepoint_callback(VALUE tracepoint, void *data)
+{
+    VALUE self = (VALUE) data;
+    rb_trace_arg_t *tracepoint_arg = rb_tracearg_from_tracepoint(tracepoint);
+    VALUE tracepoint_lineno = rb_tracearg_lineno(tracepoint_arg);
+    int c_tracepoint_lineno = NUM2INT(tracepoint_lineno);
+
+    // Only if lineno is greater than 0, then we know this event is triggered from
+    // fiber execution, and we blindly starts line_trace.
+    if (c_tracepoint_lineno > 0) {
+        enable_line_trace_for_thread(self);
+    }
+
+    return;
+}
+#endif
+
+/**
+ * register_tracepoint
+ * Helper function to create a new tracepoint and set the instance varaible on
+ * tracer if it doesn't exist already. Returns the existing tracepoint or the
+ * newly created tracepoint.
+ */
+static VALUE
+register_tracepoint(VALUE self, int event, const char *instance_variable_name, void (*call_back_func)(VALUE, void *))
+{
+    VALUE tracepoint = rb_iv_get(self, instance_variable_name);
+
+    if (event && !RTEST(tracepoint)) {
+        tracepoint = rb_tracepoint_new(Qnil, event, call_back_func, (void *)self);
+        rb_iv_set(self, instance_variable_name, tracepoint);
+    }
+
+    return tracepoint;
+}
+
+/**
+ * rb_disable_traces
+ * This is implmenetation of Tracer#disable_traces methods. It disables
+ * tracer#file_tracepoint, tracer#fiber_tracepoint, return even 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;
+
+    file_tracepoint = rb_iv_get(self, "@file_tracepoint");
+    threads = rb_funcall(rb_cThread, rb_intern("list"), 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, rb_intern("alive?"), 0))) {
+            disable_line_trace_for_thread(thread);
+            disable_return_trace_for_thread(thread);
+        }
+    }
+
+    return Qnil;
+}
+
+/**
+ * rb_enable_traces
+ * This is the implementation of Tracer#enable_traces methods. It creates
+ * the tracer#file_tracepoints and tracer#fiber_tracepoints for the first time
+ * called. Then it also enables them immediately upon creation.
+ */
+static VALUE
+rb_enable_traces(VALUE self)
+{
+    VALUE file_tracepoint;
+    VALUE fiber_tracepoint;
+
+    file_tracepoint = register_tracepoint(self, FILE_TRACEPOINT_EVENT, "@file_tracepoint", file_tracepoint_callback);
+    UNUSED(fiber_tracepoint);
+
+    // Immediately activate file tracepoint and fiber tracepoint
+    if (RTEST(file_tracepoint) && !RTEST(rb_tracepoint_enabled_p(file_tracepoint))) {
+        rb_tracepoint_enable(file_tracepoint);
+    }
+#ifdef RUBY_EVENT_FIBER_SWITCH
+    fiber_tracepoint = register_tracepoint(self, RUBY_EVENT_FIBER_SWITCH, "@fiber_tracepoint", fiber_tracepoint_callback);
+    if (RTEST(fiber_tracepoint) && !RTEST(rb_tracepoint_enabled_p(fiber_tracepoint))) {
+        rb_tracepoint_enable(fiber_tracepoint);
+    }
+#endif
+    return Qnil;
+}
+
+/**
+ * rb_disable_traces_for_thread
+ * It disables line tracing and return event tracing for current thread.
+ */
+static VALUE
+rb_disable_traces_for_thread(VALUE self)
+{
+    VALUE thread = rb_thread_current();
+    disable_line_trace_for_thread(thread);
+    disable_return_trace_for_thread(thread);
+
+    return Qnil;
+}
+
+void
+Init_tracer(VALUE mDebugger)
+{
+    VALUE cTracer = rb_define_class_under(mDebugger, "Tracer", rb_cObject);
+
+    rb_define_method(cTracer, "enable_traces", rb_enable_traces, 0);
+    rb_define_method(cTracer, "disable_traces", rb_disable_traces, 0);
+    rb_define_method(cTracer, "disable_traces_for_thread", rb_disable_traces_for_thread, 0);
+}