[k2] add backtrace_symbols (#1332)

add analogue of `backtrace_symbols` from <execinfo.h> to capture debug info if it present

Author: astrophysik

runtime-light/k2-platform/k2-header.h

@@ -458,7 +458,7 @@ int32_t k2_code_segment_offset(uint64_t* offset);
  * `ENODATA` => there is no debug information for the image
  * `EFAULT`  => attempt to dereference a nullptr
  */
-int32_t k2_symbol_name_len(const void* addr, size_t* name_len);
+int32_t k2_symbol_name_len(void* addr, size_t* name_len);
 
 /**
  * Return symbol filename's len
@@ -470,7 +470,7 @@ int32_t k2_symbol_name_len(const void* addr, size_t* name_len);
  * `ENODATA` => there is no debug information for the image
  * `EFAULT`  => attempt to dereference a nullptr
  */
-int32_t k2_symbol_filename_len(const void* addr, size_t* filename_len);
+int32_t k2_symbol_filename_len(void* addr, size_t* filename_len);
 
 struct SymbolInfo {
   char* name;
@@ -489,7 +489,7 @@ struct SymbolInfo {
  * `ENODATA` => there is no debug information for the image
  * `EFAULT`  => attempt to dereference a nullptr
  */
-int32_t k2_resolve_symbol(const void* addr, struct SymbolInfo* symbol_info);
+int32_t k2_resolve_symbol(void* addr, struct SymbolInfo* symbol_info);
 
 // ---- libc analogues, designed to work instance-local ----
 

runtime-light/stdlib/diagnostics/backtrace.h

@@ -6,24 +6,35 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <expected>
 #include <ranges>
 #include <span>
+#include <utility>
 
 #include "runtime-light/k2-platform/k2-api.h"
 
 namespace kphp::diagnostic {
 
 size_t backtrace(std::span<void*> addresses) noexcept;
 
-inline auto backtrace_code_addresses(std::span<void* const> addresses) noexcept {
-  static constexpr std::span<void* const> empty_span{};
+inline auto backtrace_addresses(std::span<void* const> addresses) noexcept {
   uint64_t code_segment_offset{};
   auto error_code{k2::code_segment_offset(&code_segment_offset)};
   auto address_transform{[code_segment_offset](void* address) noexcept { return static_cast<void*>(static_cast<std::byte*>(address) - code_segment_offset); }};
   if (error_code != k2::errno_ok) [[unlikely]] {
-    return std::views::transform(empty_span, address_transform);
+    return std::views::transform(std::span<void* const>{}, address_transform);
   }
   return addresses | std::views::transform(address_transform);
 }
 
+/**
+ * `backtrace_symbol`s stops resolving `addresses` when it finds the first address that cannot be resolved.
+ * As a result, the length of the output may be non-zero but less than the length of the input `addresses`.
+ * */
+inline auto backtrace_symbols(std::span<void* const> addresses) noexcept {
+  return addresses | std::views::transform([](void* addr) noexcept { return k2::resolve_symbol(addr); }) |
+         std::views::take_while([](const auto& value) noexcept { return value.has_value(); }) |
+         std::views::transform([](std::expected<k2::SymbolInfo, int32_t>&& value) noexcept { return std::move(value).value(); });
+}
+
 } // namespace kphp::diagnostic

runtime-light/stdlib/diagnostics/error-handling-functions.h

@@ -9,31 +9,73 @@
 #include <format>
 
 #include "runtime-common/core/runtime-core.h"
+#include "runtime-light/k2-platform/k2-api.h"
 #include "runtime-light/stdlib/diagnostics/backtrace.h"
 #include "runtime-light/utils/logs.h"
 
-inline array<array<string>> f$debug_backtrace() noexcept {
-  static constexpr size_t MAX_STACKTRACE_DEPTH = 64;
+namespace error_handling_impl_ {
+
+inline array<array<string>> format_backtrace_symbols(std::span<void* const> backtrace) noexcept {
+  auto resolved_backtrace{kphp::diagnostic::backtrace_symbols(backtrace)};
+  if (resolved_backtrace.empty()) {
+    return {};
+  }
+
+  array<array<string>> backtrace_symbols{array_size{static_cast<int64_t>(backtrace.size()), true}};
+  const string function_key{"function"};
+  const string filename_key{"file"};
+  const string line_key{"line"};
+
+  for (const k2::SymbolInfo& symbol_info : resolved_backtrace) {
+    array<string> frame_info{array_size{3, false}};
+    frame_info.set_value(function_key, string{symbol_info.name.get()});
+    frame_info.set_value(filename_key, string{symbol_info.filename.get()});
+    frame_info.set_value(line_key, string{static_cast<int64_t>(symbol_info.lineno)});
+
+    backtrace_symbols.emplace_back(std::move(frame_info));
+  }
+
+  return backtrace_symbols;
+}
+
+inline array<array<string>> format_backtrace_addresses(std::span<void* const> backtrace) noexcept {
   static constexpr size_t LOG_BUFFER_SIZE = 32;
 
-  std::array<void*, MAX_STACKTRACE_DEPTH> raw_trace{};
-  size_t num_frames{kphp::diagnostic::backtrace(raw_trace)};
-  auto resolved_backtrace{kphp::diagnostic::backtrace_code_addresses(std::span<void*>(raw_trace.data(), num_frames))};
-  if (resolved_backtrace.empty()) [[unlikely]] {
-    kphp::log::warning("cannot resolve virtual addresses to static offsets");
+  auto resolved_backtrace{kphp::diagnostic::backtrace_addresses(backtrace)};
+  if (resolved_backtrace.empty()) {
     return {};
   }
 
-  array<array<string>> backtrace{array_size{static_cast<int64_t>(num_frames), true}};
+  array<array<string>> backtrace_addresses{array_size{static_cast<int64_t>(backtrace.size()), true}};
   const string function_key{"function"};
 
   for (const auto& address : resolved_backtrace) {
     std::array<char, LOG_BUFFER_SIZE> log_buffer{};
     const auto [_, recorded]{std::format_to_n(log_buffer.data(), log_buffer.size() - 1, "{}", address)};
     array<string> frame_info{array_size{1, false}};
     frame_info.set_value(function_key, string{log_buffer.data(), static_cast<string::size_type>(recorded)});
-    backtrace.emplace_back(std::move(frame_info));
+
+    backtrace_addresses.emplace_back(std::move(frame_info));
   }
 
-  return backtrace;
+  return backtrace_addresses;
+}
+} // namespace error_handling_impl_
+
+inline array<array<string>> f$debug_backtrace() noexcept {
+  static constexpr size_t MAX_STACKTRACE_DEPTH = 64;
+
+  std::array<void*, MAX_STACKTRACE_DEPTH> backtrace{};
+  size_t num_frames{kphp::diagnostic::backtrace(backtrace)};
+  std::span<void*> backtrace_view{backtrace.data(), num_frames};
+  auto backtrace_symbols{error_handling_impl_::format_backtrace_symbols(backtrace_view)};
+  if (!backtrace_symbols.empty()) {
+    return backtrace_symbols;
+  }
+  auto backtrace_code_addresses{error_handling_impl_::format_backtrace_addresses(backtrace_view)};
+  if (!backtrace_code_addresses.empty()) {
+    return backtrace_code_addresses;
+  }
+  kphp::log::warning("cannot resolve virtual addresses to debug information");
+  return {};
 }

tests/python/lib/testcase.py

@@ -207,6 +207,7 @@ def custom_setup(cls):
 
             if cls.should_use_k2():
                 kphp_env.update(cls.kphp_env_for_k2_server_component())
+            kphp_env.update(cls.extra_kphp2cpp_options())
 
             print("\nCompiling kphp")
             if not cls.kphp_builder.compile_with_kphp(kphp_env):
@@ -255,6 +256,14 @@ def custom_setup_method(self, method):
     def custom_teardown_method(self, method):
         self.web_server._engine_logs = []
 
+    @classmethod
+    def extra_kphp2cpp_options(cls):
+        """
+        This method can be overloaded in a test case.
+        The result should be a dictionary that will be added as environment variables in kphp2cpp
+        """
+        return {}
+
     @classmethod
     def extra_class_setup(cls):
         """

tests/python/tests/diagnostic/php/data/component-config.yaml

@@ -0,0 +1,7 @@
+entry: script
+components:
+  script:
+    image: KPHP
+    scope: Request
+    args: {}
+    links: {}

tests/python/tests/diagnostic/php/index.php

@@ -0,0 +1,113 @@
+<?php
+
+function my_array_find($arr, callable $callback) {
+    foreach($arr as $element) {
+        if ($callback($element)) {
+            return $element;
+        }
+    }
+    return null;
+}
+
+function capture_backtrace() {
+#ifndef K2
+    $trace = kphp_backtrace();
+    $backtrace = [];
+    foreach($trace as $function) {
+        $backtrace[] = ["function" => $function];
+    }
+    // kphp_backtrace doesn't capture coro trace after coroutine suspending
+    $backtrace[] = ["function" => "coro_fun3"];
+    $backtrace[] = ["function" => "coro_fun2"];
+    $backtrace[] = ["function" => "coro_fun1"];
+    return $backtrace;
+#endif
+    return debug_backtrace();
+}
+
+
+function check_backtrace($backtrace) {
+    $ok = true;
+    $trace = ["sync_fun2", "sync_fun1", "coro_fun3", "coro_fun2", "coro_fun1"];
+
+    foreach ($trace as $symbol) {
+        $ok &= my_array_find($backtrace, function(array $value) use($symbol) {
+            return stristr($value["function"], $symbol) != false;
+            }) != null;
+        if (!$ok) {
+            return $symbol . " is absent";
+        }
+    }
+
+    return "ok";
+}
+
+
+function sync_fun2(bool $b) {
+    while(0);
+    $trace = capture_backtrace();
+    return check_backtrace($trace);
+}
+
+function sync_fun1(int $x) {
+    while(0);
+    return sync_fun2($x > 0);
+}
+
+function coro_fun3(?array $x) {
+    while(0);
+    sched_yield_sleep(0.01);
+    $res = sync_fun1($x ? count($x) : -1);
+    return $res;
+}
+
+function coro_fun2(array $x) {
+    while(0);
+    return coro_fun3(false ? $x : null);
+}
+
+function coro_fun1() {
+    while(0);
+    return coro_fun2([1, 2, 3, 4, 5, 6, 7]);
+}
+
+function forkable() {
+    $f = fork(coro_fun1());
+    return wait($f);
+}
+
+function main() {
+    foreach (json_decode(file_get_contents('php://input')) as $action) {
+        switch ($action["op"]) {
+            case "check_main_trace":
+                $res = coro_fun1();
+                echo $res;
+                break;
+            case "check_fork_trace":
+                $f = fork(coro_fun1());
+                $res = wait($f);
+                echo $res;
+                break;
+            case "check_fork_switch_trace":
+                $f_1 = fork(coro_fun1());
+                $f_2 = fork(coro_fun3([]));
+
+                $res_1 = wait($f_1);
+                $_ = wait($f_2);
+
+                echo $res_1;
+                break;
+            case "check_nested_fork_trace":
+                $f = fork(forkable());
+                $res = wait($f);
+                echo $res;
+                break;
+            default:
+                echo "unknown operation";
+                return;
+        }
+    }
+}
+
+main();
+

tests/python/tests/diagnostic/test_backtrace.py

@@ -0,0 +1,40 @@
+import pytest
+from python.lib.testcase import WebServerAutoTestCase
+
+
+class TestBacktrace(WebServerAutoTestCase):
+    @classmethod
+    def extra_kphp2cpp_options(cls):
+        return {"KPHP_EXTRA_CXXFLAGS" : "-O0 -g"}
+
+    def test_main_fork_trace(self):
+        resp = self.web_server.http_post(
+            json=[
+                {"op": "check_main_trace"},
+            ])
+        self.assertEqual(resp.text, "ok")
+        self.assertEqual(resp.status_code, 200)
+
+    def test_fork_trace(self):
+        resp = self.web_server.http_post(
+            json=[
+                {"op": "check_fork_trace"},
+            ])
+        self.assertEqual(resp.text, "ok")
+        self.assertEqual(resp.status_code, 200)
+
+    def test_fork_switch_trace(self):
+        resp = self.web_server.http_post(
+            json=[
+                {"op": "check_fork_switch_trace"},
+            ])
+        self.assertEqual(resp.text, "ok")
+        self.assertEqual(resp.status_code, 200)
+
+    def test_nested_fork_trace(self):
+        resp = self.web_server.http_post(
+            json=[
+                {"op": "check_nested_fork_trace"},
+            ])
+        self.assertEqual(resp.text, "ok")
+        self.assertEqual(resp.status_code, 200)