arm64: define the KASAN_SHADOW_SCALE_SHIFT macro

CHANGELOG.md

@@ -27,6 +27,8 @@ and this project adheres to
   - [#2545](https://github.com/iovisor/bpftrace/pull/2545)
 - Treat str() builtin's len parameter as int64
   - [#2546](https://github.com/iovisor/bpftrace/pull/2546)
+- arm64: define the KASAN_SHADOW_SCALE_SHIFT macro
+  - [#2518](https://github.com/iovisor/bpftrace/pull/2518)
 #### Docs
 #### Tools
 

src/bpftrace.h

@@ -168,6 +168,7 @@ class BPFtrace
   std::map<libbpf::bpf_func_id, location> helper_use_loc_;
   // mapping traceable functions to modules (or "vmlinux") that they appear in
   FuncsModulesMap traceable_funcs_;
+  KConfig kconfig;
   std::vector<std::unique_ptr<AttachedProbe>> attached_probes_;
 
   std::map<std::string, std::unique_ptr<PCAPwriter>> pcap_writers;

src/main.cpp

@@ -369,7 +369,8 @@ static std::optional<struct timespec> get_boottime()
     kobj = std::get<1>(kdirs);
 
     if (ksrc != "")
-      extra_flags = get_kernel_cflags(utsname.machine, ksrc, kobj);
+      extra_flags = get_kernel_cflags(
+          utsname.machine, ksrc, kobj, bpftrace.kconfig);
   }
   extra_flags.push_back("-include");
   extra_flags.push_back(CLANG_WORKAROUNDS_H);

src/utils.cpp

@@ -28,6 +28,7 @@
 #include <bcc/bcc_syms.h>
 #include <bcc/bcc_usdt.h>
 #include <elf.h>
+#include <zlib.h>
 
 #include <linux/version.h>
 
@@ -178,6 +179,55 @@ StdioSilencer::~StdioSilencer()
   }
 }
 
+KConfig::KConfig()
+{
+  std::vector<std::string> config_locs;
+
+  // Try to get the config from BPFTRACE_KCONFIG_TEST env
+  // If not set, use the set of default locations
+  const char *path_env = std::getenv("BPFTRACE_KCONFIG_TEST");
+  if (path_env)
+    config_locs = { std::string(path_env) };
+  else
+  {
+    struct utsname utsname;
+    if (uname(&utsname) < 0)
+      return;
+    config_locs = {
+      "/proc/config.gz",
+      "/boot/config-" + std::string(utsname.release),
+    };
+  }
+
+  for (auto &path : config_locs)
+  {
+    // gzopen/gzgets handle both uncompressed and compressed files
+    gzFile file = gzopen(path.c_str(), "r");
+    if (!file)
+      continue;
+
+    char buf[4096];
+    while (gzgets(file, buf, sizeof(buf)))
+    {
+      std::string option(buf);
+      if (option.find("CONFIG_") == 0)
+      {
+        // trim trailing '\n'
+        if (option[option.length() - 1] == '\n')
+          option = option.substr(0, option.length() - 1);
+
+        auto split = option.find("=");
+        if (split == std::string::npos)
+          continue;
+
+        config.emplace(option.substr(0, split), option.substr(split + 1));
+      }
+    }
+    gzclose(file);
+    break;
+  }
+}
+
 bool get_uint64_env_var(const std::string &str, uint64_t &dest)
 {
   if (const char* env_p = std::getenv(str.c_str()))
@@ -314,10 +364,10 @@ std::vector<int> get_possible_cpus()
   return read_cpu_range("/sys/devices/system/cpu/possible");
 }
 
-std::vector<std::string> get_kernel_cflags(
-    const char* uname_machine,
-    const std::string& ksrc,
-    const std::string& kobj)
+std::vector<std::string> get_kernel_cflags(const char *uname_machine,
+                                           const std::string &ksrc,
+                                           const std::string &kobj,
+                                           const KConfig &kconfig)
 {
   std::vector<std::string> cflags;
   std::string arch = uname_machine;
@@ -383,6 +433,20 @@ std::vector<std::string> get_kernel_cflags(
     cflags.push_back("-D__LINUX_ARM_ARCH__=7");
   }
 
+  if (arch == "arm64")
+  {
+    // arm64 defines KASAN_SHADOW_SCALE_SHIFT in a Makefile instead of defining
+    // it in a header file. Since we're not executing make, we need to set the
+    // value manually (values are taken from arch/arm64/Makefile).
+    if (kconfig.has_value("CONFIG_KASAN", "y"))
+    {
+      if (kconfig.has_value("CONFIG_KASAN_SW_TAGS", "y"))
+        cflags.push_back("-DKASAN_SHADOW_SCALE_SHIFT=4");
+      else
+        cflags.push_back("-DKASAN_SHADOW_SCALE_SHIFT=3");
+    }
+  }
+
   return cflags;
 }
 

src/utils.h

@@ -130,6 +130,18 @@ struct DeprecatedName
 typedef std::unordered_map<std::string, std::unordered_set<std::string>>
     FuncsModulesMap;
 
+struct KConfig
+{
+  KConfig();
+  bool has_value(const std::string &name, const std::string &value) const
+  {
+    auto c = config.find(name);
+    return c != config.end() && c->second == value;
+  }
+
+  std::unordered_map<std::string, std::string> config;
+};
+
 static std::vector<DeprecatedName> DEPRECATED_LIST =
 {
 };
@@ -166,7 +178,8 @@ std::tuple<std::string, std::string> get_kernel_dirs(
     bool unpack_kheaders);
 std::vector<std::string> get_kernel_cflags(const char *uname_machine,
                                            const std::string &ksrc,
-                                           const std::string &kobj);
+                                           const std::string &kobj,
+                                           const KConfig &kconfig);
 std::string get_cgroup_path_in_hierarchy(uint64_t cgroupid,
                                          std::string base_path);
 std::vector<std::pair<std::string, std::string>> get_cgroup_hierarchy_roots();

tests/utils.cpp

@@ -222,6 +222,28 @@ TEST(utils, get_cgroup_path_in_hierarchy)
   }
 }
 
+TEST(utils, parse_kconfig)
+{
+  char path[] = "/tmp/configXXXXXX";
+  int fd = mkstemp(path);
+  const std::string config = "# Intro comment\n"
+                             "CONFIG_YES=y\n"
+                             "CONFIG_MOD=m\n"
+                             "CONFIG_VAL=42\n"
+                             "# CONFIG_NO is not set";
+  EXPECT_EQ(write(fd, config.c_str(), config.length()), config.length());
+  setenv("BPFTRACE_KCONFIG_TEST", path, true);
+  close(fd);
+
+  KConfig kconfig;
+  ASSERT_TRUE(kconfig.has_value("CONFIG_YES", "y"));
+  ASSERT_TRUE(kconfig.has_value("CONFIG_MOD", "m"));
+  ASSERT_TRUE(kconfig.has_value("CONFIG_VAL", "42"));
+  ASSERT_EQ(kconfig.config.find("CONFIG_NO"), kconfig.config.end());
+
+  unlink(path);
+}
+
 } // namespace utils
 } // namespace test
 } // namespace bpftrace