Import from AlmaLinux stable repository

.bpftrace.metadata

@@ -1 +0,0 @@
-1b1d4e5058e07f82904971e65733791b25ef5263 SOURCES/bpftrace-0.10.0.tar.gz

.gitignore

@@ -1 +1,2 @@
-SOURCES/bpftrace-0.10.0.tar.gz
+SOURCES/bpftrace-0.16.0.tar.gz
+SOURCES/cereal-1.3.2.tar.gz

SOURCES/bpftrace-0.10.0-Add-s390x-register-support.patch

@@ -1,126 +0,0 @@
-From 3516f05627b33cb2e6e74965650c6d6c043f78f9 Mon Sep 17 00:00:00 2001
-From: Sumanth Korikkar <sumanthk@linux.ibm.com>
-Date: Mon, 6 Apr 2020 09:23:34 +0200
-Subject: [PATCH] bpftrace: Add s390x register support
-
-Add s390x specific registers. This is needed for bpftrace builtins like argX,
-regs(), retval etc. This commit provides various functions to perform proper
-offset calculation from the pt_regs context. The builtin functions of
-bpftrace uses these offset functions to generate the proper bytecode for s390x
-
-Signed-off-by: Sumanth Korikkar <sumanthk@linux.ibm.com>
-Acked-by: Ilya Leoshkevich <iii@linux.ibm.com>
----
- src/arch/CMakeLists.txt |  3 ++
- src/arch/s390.cpp       | 85 +++++++++++++++++++++++++++++++++++++++++
- 2 files changed, 88 insertions(+)
- create mode 100644 src/arch/s390.cpp
-
-diff --git a/src/arch/CMakeLists.txt b/src/arch/CMakeLists.txt
-index 7156276..51707cb 100644
---- a/src/arch/CMakeLists.txt
-+++ b/src/arch/CMakeLists.txt
-@@ -3,6 +3,9 @@ if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
- elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64" OR
-        CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64le")
-     add_library(arch ppc64.cpp)
-+elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "s390" OR
-+       CMAKE_SYSTEM_PROCESSOR STREQUAL "s390x")
-+    add_library(arch s390.cpp)
- elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-     add_library(arch x86_64.cpp)
- else()
-diff --git a/src/arch/s390.cpp b/src/arch/s390.cpp
-new file mode 100644
-index 0000000..a2278c8
---- /dev/null
-+++ b/src/arch/s390.cpp
-@@ -0,0 +1,85 @@
-+#include "arch.h"
-+
-+#include <algorithm>
-+#include <array>
-+
-+#define REQ_REGISTERS 19
-+#define ARG_REGISTERS 5
-+
-+namespace bpftrace {
-+namespace arch {
-+
-+// clang-format off
-+static std::array<std::string, REQ_REGISTERS> registers = {
-+  // Breakpoint event address
-+  "arg",
-+  "pswmask",
-+  // Instruction address
-+  "pswaddr",
-+  "r0",
-+  "r1",
-+  "r2",
-+  "r3",
-+  "r4",
-+  "r5",
-+  "r6",
-+  "r7",
-+  "r8",
-+  "r9",
-+  "r10",
-+  "r11",
-+  "r12",
-+  "r13",
-+  "r14",
-+  "r15",
-+};
-+
-+static std::array<std::string, ARG_REGISTERS> arg_registers = {
-+  "r2",
-+  "r3",
-+  "r4",
-+  "r5",
-+  "r6",
-+};
-+// clang-format on
-+
-+int offset(std::string reg_name)
-+{
-+  auto it = find(registers.begin(), registers.end(), reg_name);
-+  if (it == registers.end())
-+    return -1;
-+  return distance(registers.begin(), it);
-+}
-+
-+int max_arg()
-+{
-+  return arg_registers.size() - 1;
-+}
-+
-+int arg_offset(int arg_num)
-+{
-+  return offset(arg_registers.at(arg_num));
-+}
-+
-+int ret_offset()
-+{
-+  return offset("r2");
-+}
-+
-+int pc_offset()
-+{
-+  return offset("pswaddr");
-+}
-+
-+int sp_offset()
-+{
-+  return offset("r15");
-+}
-+
-+std::string name()
-+{
-+  return std::string("s390x");
-+}
-+
-+} // namespace arch
-+} // namespace bpftrace
--- 
-2.25.3
-

SOURCES/bpftrace-0.10.0-Fix-KBUILD_MODNAME.patch

@@ -1,27 +0,0 @@
-From 042675755d1ec2446105af700cd9cfb1bace905c Mon Sep 17 00:00:00 2001
-From: Masanori Misono <m.misono760@gmail.com>
-Date: Wed, 27 May 2020 17:54:52 +0900
-Subject: [PATCH] Fix KBUILD_MODNAME
-
-Use "bpftrace" instead of '"bpftrace"'. Previously this causes build
-error if included header files use KBUILD_MODNAME.
----
- src/utils.cpp | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/src/utils.cpp b/src/utils.cpp
-index dc82689..cec77cf 100644
---- a/src/utils.cpp
-+++ b/src/utils.cpp
-@@ -363,7 +363,7 @@ std::vector<std::string> get_kernel_cflags(
-   cflags.push_back("-D__HAVE_BUILTIN_BSWAP16__");
-   cflags.push_back("-D__HAVE_BUILTIN_BSWAP32__");
-   cflags.push_back("-D__HAVE_BUILTIN_BSWAP64__");
--  cflags.push_back("-DKBUILD_MODNAME='\"bpftrace\"'");
-+  cflags.push_back("-DKBUILD_MODNAME=\"bpftrace\"");
- 
-   // If ARCH env variable is set, pass this along.
-   if (archenv)
--- 
-2.25.4
-

SOURCES/bpftrace-0.10.0-RHEL-8-fixes.patch

@@ -1,56 +0,0 @@
-From a09a2f06d6316801e89e7f676d0839910aea765d Mon Sep 17 00:00:00 2001
-From: Jerome Marchand <jmarchan@redhat.com>
-Date: Tue, 11 Jun 2019 16:41:59 +0200
-Subject: [PATCH] RHEL 8 fixes
-
-Fixes the following RHEL 8 specific issues:
- - library path in gethostlatency and threadsnoop
----
- tools/gethostlatency.bt | 12 ++++++------
- tools/threadsnoop.bt    |  2 +-
- 2 files changed, 7 insertions(+), 7 deletions(-)
-
-diff --git a/tools/gethostlatency.bt b/tools/gethostlatency.bt
-index a1ac1b2..ade1005 100755
---- a/tools/gethostlatency.bt
-+++ b/tools/gethostlatency.bt
-@@ -26,17 +26,17 @@ BEGIN
- 	    "HOST");
- }
- 
--uprobe:/lib/x86_64-linux-gnu/libc.so.6:getaddrinfo,
--uprobe:/lib/x86_64-linux-gnu/libc.so.6:gethostbyname,
--uprobe:/lib/x86_64-linux-gnu/libc.so.6:gethostbyname2
-+uprobe:/lib64/libc.so.6:getaddrinfo,
-+uprobe:/lib64/libc.so.6:gethostbyname,
-+uprobe:/lib64/libc.so.6:gethostbyname2
- {
- 	@start[tid] = nsecs;
- 	@name[tid] = arg0;
- }
- 
--uretprobe:/lib/x86_64-linux-gnu/libc.so.6:getaddrinfo,
--uretprobe:/lib/x86_64-linux-gnu/libc.so.6:gethostbyname,
--uretprobe:/lib/x86_64-linux-gnu/libc.so.6:gethostbyname2
-+uretprobe:/lib64/libc.so.6:getaddrinfo,
-+uretprobe:/lib64/libc.so.6:gethostbyname,
-+uretprobe:/lib64/libc.so.6:gethostbyname2
- /@start[tid]/
- {
- 	$latms = (nsecs - @start[tid]) / 1000000;
-diff --git a/tools/threadsnoop.bt b/tools/threadsnoop.bt
-index e4d3875..c56b1ac 100755
---- a/tools/threadsnoop.bt
-+++ b/tools/threadsnoop.bt
-@@ -18,7 +18,7 @@ BEGIN
- 	printf("%-10s %-6s %-16s %s\n", "TIME(ms)", "PID", "COMM", "FUNC");
- }
- 
--uprobe:/lib/x86_64-linux-gnu/libpthread.so.0:pthread_create
-+uprobe:/usr/lib64/libpthread.so:pthread_create
- {
- 	printf("%-10u %-6d %-16s %s\n", elapsed / 1000000, pid, comm,
- 	    usym(arg2));
--- 
-2.25.4
-

SOURCES/bpftrace-0.10.0-Remove-RLIMIT_AS-limit.patch

@@ -1,73 +0,0 @@
-From 604c9d5619ca01a46c208a70b7beec3041ba77a9 Mon Sep 17 00:00:00 2001
-From: Daniel Xu <dxu@dxuuu.xyz>
-Date: Thu, 28 May 2020 23:12:47 -0700
-Subject: [PATCH] Remove RLIMIT_AS limit
-
-We haven't seen any OOM issues in a while so I suspect either our type
-fixes in bpftrace or upstream llvm changes have resolved the issue.
-
-This closes #1355.
----
- src/CMakeLists.txt |  1 -
- src/main.cpp       | 26 --------------------------
- 2 files changed, 27 deletions(-)
-
-diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
-index 4fa0418..ac040f4 100644
---- a/src/CMakeLists.txt
-+++ b/src/CMakeLists.txt
-@@ -99,7 +99,6 @@ if (BUILD_ASAN)
-     # target_link_options is supported in CMake 3.13 and newer
-     message("Please use CMake 3.13 or newer to enable ASAN")
-   endif()
--  target_compile_definitions(bpftrace PRIVATE BUILD_ASAN)
-   target_compile_options(bpftrace PUBLIC "-fsanitize=address")
-   target_link_options(bpftrace PUBLIC "-fsanitize=address")
- endif()
-diff --git a/src/main.cpp b/src/main.cpp
-index 4ff9d37..d92ea8d 100644
---- a/src/main.cpp
-+++ b/src/main.cpp
-@@ -92,30 +92,6 @@ static void enforce_infinite_rlimit() {
-         "\"ulimit -l 8192\" to fix the problem" << std::endl;
- }
- 
--#ifdef BUILD_ASAN
--static void cap_memory_limits()
--{
--}
--#else
--static void cap_memory_limits() {
--  struct rlimit rl = {};
--  int err;
--  uint64_t memory_limit_bytes = 1 * 1024 * 1024 * 1024;
--
--  // this is a safety measure for issue #528 "LLVM ERROR: out of memory",
--  // and caps bpftrace memory to 1 Gbyte. This may be removed once the LLVM
--  // issue has been fixed, and this is no longer deemed necessary.
--  rl.rlim_max = memory_limit_bytes;
--  rl.rlim_cur = rl.rlim_max;
--  err = setrlimit(RLIMIT_AS, &rl);
--  err += setrlimit(RLIMIT_RSS, &rl);
--  if (err)
--    std::cerr << std::strerror(err)<<": couldn't set RLIMIT_AS and " <<
--        "RLIMIT_RSS for bpftrace (these are a temporary precaution to stop " <<
--        "accidental large program loads, and are not required" << std::endl;
--}
--#endif // BUILD_ASAN
--
- bool is_root()
- {
-   if (geteuid() != 0)
-@@ -425,8 +401,6 @@ int main(int argc, char *argv[])
-   // rlimit?
-   enforce_infinite_rlimit();
- 
--  cap_memory_limits();
--
-   // positional parameters
-   while (optind < argc) {
-     bpftrace.add_param(argv[optind]);
--- 
-2.25.4
-

SOURCES/bpftrace-0.16.0-Adjust-to-build-with-llvm-17.patch

@@ -0,0 +1,90 @@
+From 45f0302773923accd7cc324d839b733c27c92f38 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 6 Jul 2023 08:59:41 -0700
+Subject: [PATCH] Adjust to build with llvm 17
+
+- PassManagerBuilder has been removed
+- itaniumDemangle() API signature has changed
+- update MAX_LLVM_MAJOR in CMakeLists.txt
+- update bcc and libbpf submodules to their latest versions to allow
+  building bcc with llvm 17
+- replaced JITEvaluatedSymbol by ExecutorSymbolDef in ORC
+
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+Signed-off-by: Viktor Malik <viktor.malik@gmail.com>
+---
+ CMakeLists.txt                         | 2 +-
+ src/ast/bpforc/bpforc.h                | 2 +-
+ src/ast/passes/codegen_llvm.cpp        | 4 ++++
+ src/cxxdemangler/cxxdemangler_llvm.cpp | 4 ++++
+ 4 files changed, 10 insertions(+), 2 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 433153be..a11a5c36 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -169,7 +169,7 @@ else()
+   endif()
+ 
+   set(MIN_LLVM_MAJOR 6)
+-  set(MAX_LLVM_MAJOR 16)
++  set(MAX_LLVM_MAJOR 17)
+ 
+   if((${LLVM_VERSION_MAJOR} VERSION_LESS ${MIN_LLVM_MAJOR}) OR (${LLVM_VERSION_MAJOR} VERSION_GREATER ${MAX_LLVM_MAJOR}))
+     message(SEND_ERROR "Unsupported LLVM version found via ${LLVM_INCLUDE_DIRS}: ${LLVM_VERSION_MAJOR}")
+diff --git a/src/ast/bpforc/bpforc.h b/src/ast/bpforc/bpforc.h
+index 58914419..8d2f1e63 100644
+--- a/src/ast/bpforc/bpforc.h
++++ b/src/ast/bpforc/bpforc.h
+@@ -157,7 +157,7 @@ public:
+   }
+ 
+ #ifdef LLVM_ORC_V2
+-  Expected<JITEvaluatedSymbol> lookup(StringRef Name)
++  Expected<ExecutorSymbolDef> lookup(StringRef Name)
+   {
+     return ES->lookup({ &MainJD }, Mangle(Name.str()));
+   }
+diff --git a/src/ast/passes/codegen_llvm.cpp b/src/ast/passes/codegen_llvm.cpp
+index 2b888087..a75a0fd1 100644
+--- a/src/ast/passes/codegen_llvm.cpp
++++ b/src/ast/passes/codegen_llvm.cpp
+@@ -7,7 +7,9 @@
+ #include <ctime>
+ #include <fstream>
+ 
++#if LLVM_VERSION_MAJOR <= 16
+ #include <llvm-c/Transforms/IPO.h>
++#endif
+ #include <llvm/IR/Constants.h>
+ #include <llvm/IR/LLVMContext.h>
+ #include <llvm/IR/LegacyPassManager.h>
+@@ -17,7 +19,9 @@
+ #include <llvm/Passes/PassBuilder.h>
+ #endif
+ #include <llvm/Transforms/IPO.h>
++#if LLVM_VERSION_MAJOR <= 16
+ #include <llvm/Transforms/IPO/PassManagerBuilder.h>
++#endif
+ 
+ #include "arch/arch.h"
+ #include "ast.h"
+diff --git a/src/cxxdemangler/cxxdemangler_llvm.cpp b/src/cxxdemangler/cxxdemangler_llvm.cpp
+index e9a9db24..1b0bf7ea 100644
+--- a/src/cxxdemangler/cxxdemangler_llvm.cpp
++++ b/src/cxxdemangler/cxxdemangler_llvm.cpp
+@@ -6,7 +6,11 @@ namespace bpftrace {
+ 
+ char* cxxdemangle(const char* mangled)
+ {
++#if LLVM_VERSION_MAJOR <= 16
+   return llvm::itaniumDemangle(mangled, nullptr, nullptr, nullptr);
++#else
++  return llvm::itaniumDemangle(mangled);
++#endif
+ }
+ 
+ } // namespace bpftrace
+-- 
+2.41.0
+

SOURCES/bpftrace-0.16.0-IR-builder-get-rid-of-getPointerElementType-calls.patch

@@ -0,0 +1,457 @@
+From dfc1f92653707c8d11bdb3be98e68f8297b9bc71 Mon Sep 17 00:00:00 2001
+From: Viktor Malik <viktor.malik@gmail.com>
+Date: Mon, 10 Oct 2022 14:26:38 +0200
+Subject: [PATCH] IR builder: get rid of getPointerElementType calls
+
+Usage of Value::getPointerElementType is deprecated and will be dropped
+in LLVM 16 [1].
+
+There are several places where we use this method:
+- function (value) calls - the called function type is usually
+  available, so just pass it to createCall, the only exception is
+  CreateProbeReadStr which must have been refactored
+- getting the type of alloca instruction - there is a dedicated
+  AllocaInst::getAllocatedType method that can be used instead
+- strncmp - pass sizes of the strings to CreateStrncmp to be able to get
+  the correct string type (which is array of uint8)
+
+[1] https://llvm.org/docs/OpaquePointers.html
+---
+ src/ast/irbuilderbpf.cpp        | 143 ++++++++++++--------------------
+ src/ast/irbuilderbpf.h          |  23 +++--
+ src/ast/passes/codegen_llvm.cpp |  30 +++++--
+ 3 files changed, 86 insertions(+), 110 deletions(-)
+
+diff --git a/src/ast/irbuilderbpf.cpp b/src/ast/irbuilderbpf.cpp
+index d49883f7..4036b2df 100644
+--- a/src/ast/irbuilderbpf.cpp
++++ b/src/ast/irbuilderbpf.cpp
+@@ -288,17 +288,16 @@ CallInst *IRBuilderBPF::CreateHelperCall(libbpf::bpf_func_id func_id,
+   Constant *helper_func = ConstantExpr::getCast(Instruction::IntToPtr,
+                                                 getInt64(func_id),
+                                                 helper_ptr_type);
+-  return createCall(helper_func, args, Name);
++  return createCall(helper_type, helper_func, args, Name);
+ }
+ 
+-CallInst *IRBuilderBPF::createCall(Value *callee,
++CallInst *IRBuilderBPF::createCall(FunctionType *callee_type,
++                                   Value *callee,
+                                    ArrayRef<Value *> args,
+                                    const Twine &Name)
+ {
+ #if LLVM_VERSION_MAJOR >= 11
+-  auto *calleePtrType = cast<PointerType>(callee->getType());
+-  auto *calleeType = cast<FunctionType>(calleePtrType->getPointerElementType());
+-  return CreateCall(calleeType, callee, args, Name);
++  return CreateCall(callee_type, callee, args, Name);
+ #else
+   return CreateCall(callee, args, Name);
+ #endif
+@@ -307,7 +306,7 @@ CallInst *IRBuilderBPF::createCall(Value *callee,
+ CallInst *IRBuilderBPF::CreateBpfPseudoCallId(int mapid)
+ {
+   Function *pseudo_func = module_.getFunction("llvm.bpf.pseudo");
+-  return createCall(pseudo_func,
++  return CreateCall(pseudo_func,
+                     { getInt64(BPF_PSEUDO_MAP_FD), getInt64(mapid) },
+                     "pseudo");
+ }
+@@ -346,7 +345,8 @@ CallInst *IRBuilderBPF::createMapLookup(int mapid, Value *key)
+       Instruction::IntToPtr,
+       getInt64(libbpf::BPF_FUNC_map_lookup_elem),
+       lookup_func_ptr_type);
+-  return createCall(lookup_func, { map_ptr, key }, "lookup_elem");
++  return createCall(
++      lookup_func_type, lookup_func, { map_ptr, key }, "lookup_elem");
+ }
+ 
+ CallInst *IRBuilderBPF::CreateGetJoinMap(Value *ctx, const location &loc)
+@@ -397,8 +397,7 @@ Value *IRBuilderBPF::CreateMapLookupElem(Value *ctx,
+     CREATE_MEMCPY(value, call, type.GetSize(), 1);
+   else
+   {
+-    assert(value->getType()->isPointerTy() &&
+-           (value->getType()->getPointerElementType() == getInt64Ty()));
++    assert(value->getAllocatedType() == getInt64Ty());
+     // createMapLookup  returns an u8*
+     auto *cast = CreatePointerCast(call, value->getType(), "cast");
+     CreateStore(CreateLoad(getInt64Ty(), cast), value);
+@@ -448,7 +447,8 @@ void IRBuilderBPF::CreateMapUpdateElem(Value *ctx,
+       Instruction::IntToPtr,
+       getInt64(libbpf::BPF_FUNC_map_update_elem),
+       update_func_ptr_type);
+-  CallInst *call = createCall(update_func,
++  CallInst *call = createCall(update_func_type,
++                              update_func,
+                               { map_ptr, key, val, flags },
+                               "update_elem");
+   CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_map_update_elem, loc);
+@@ -472,7 +472,8 @@ void IRBuilderBPF::CreateMapDeleteElem(Value *ctx,
+       Instruction::IntToPtr,
+       getInt64(libbpf::BPF_FUNC_map_delete_elem),
+       delete_func_ptr_type);
+-  CallInst *call = createCall(delete_func, { map_ptr, key }, "delete_elem");
++  CallInst *call = createCall(
++      delete_func_type, delete_func, { map_ptr, key }, "delete_elem");
+   CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_map_delete_elem, loc);
+ }
+ 
+@@ -508,72 +509,53 @@ void IRBuilderBPF::CreateProbeRead(Value *ctx,
+   Constant *proberead_func = ConstantExpr::getCast(Instruction::IntToPtr,
+                                                    getInt64(read_fn),
+                                                    proberead_func_ptr_type);
+-  CallInst *call = createCall(proberead_func,
++  CallInst *call = createCall(proberead_func_type,
++                              proberead_func,
+                               { dst, size, src },
+                               probeReadHelperName(read_fn));
+   CreateHelperErrorCond(ctx, call, read_fn, loc);
+ }
+ 
+-Constant *IRBuilderBPF::createProbeReadStrFn(llvm::Type *dst,
+-                                             llvm::Type *src,
+-                                             AddrSpace as)
+-{
+-  assert(src && (src->isIntegerTy() || src->isPointerTy()));
+-  // int bpf_probe_read_str(void *dst, int size, const void *unsafe_ptr)
+-  FunctionType *probereadstr_func_type = FunctionType::get(
+-      getInt64Ty(), { dst, getInt32Ty(), src }, false);
+-  PointerType *probereadstr_func_ptr_type = PointerType::get(
+-      probereadstr_func_type, 0);
+-  return ConstantExpr::getCast(Instruction::IntToPtr,
+-                               getInt64(selectProbeReadHelper(as, true)),
+-                               probereadstr_func_ptr_type);
+-}
+-
+ CallInst *IRBuilderBPF::CreateProbeReadStr(Value *ctx,
+-                                           AllocaInst *dst,
++                                           Value *dst,
+                                            size_t size,
+                                            Value *src,
+                                            AddrSpace as,
+                                            const location &loc)
+ {
+-  assert(ctx && ctx->getType() == getInt8PtrTy());
+   return CreateProbeReadStr(ctx, dst, getInt32(size), src, as, loc);
+ }
+ 
+ CallInst *IRBuilderBPF::CreateProbeReadStr(Value *ctx,
+                                            Value *dst,
+-                                           size_t size,
+-                                           Value *src,
+-                                           AddrSpace as,
+-                                           const location &loc)
+-{
+-  assert(ctx && ctx->getType() == getInt8PtrTy());
+-  Constant *fn = createProbeReadStrFn(dst->getType(), src->getType(), as);
+-  auto read_fn = selectProbeReadHelper(as, true);
+-  CallInst *call = createCall(fn,
+-                              { dst, getInt32(size), src },
+-                              probeReadHelperName(read_fn));
+-  CreateHelperErrorCond(ctx, call, read_fn, loc);
+-  return call;
+-}
+-
+-CallInst *IRBuilderBPF::CreateProbeReadStr(Value *ctx,
+-                                           AllocaInst *dst,
+                                            llvm::Value *size,
+                                            Value *src,
+                                            AddrSpace as,
+                                            const location &loc)
+ {
+   assert(ctx && ctx->getType() == getInt8PtrTy());
+-  assert(dst && dst->getAllocatedType()->isArrayTy() &&
+-         dst->getAllocatedType()->getArrayElementType() == getInt8Ty());
+   assert(size && size->getType()->isIntegerTy());
++  if (auto *dst_alloca = dyn_cast<AllocaInst>(dst))
++  {
++    assert(dst_alloca->getAllocatedType()->isArrayTy() &&
++           dst_alloca->getAllocatedType()->getArrayElementType() ==
++               getInt8Ty());
++  }
+ 
+-  auto *size_i32 = CreateIntCast(size, getInt32Ty(), false);
++  auto *size_i32 = size;
++  if (size_i32->getType()->getScalarSizeInBits() != 32)
++    size_i32 = CreateIntCast(size_i32, getInt32Ty(), false);
+ 
+-  Constant *fn = createProbeReadStrFn(dst->getType(), src->getType(), as);
+   auto read_fn = selectProbeReadHelper(as, true);
+-  CallInst *call = createCall(fn,
++  // int bpf_probe_read_str(void *dst, int size, const void *unsafe_ptr)
++  FunctionType *probereadstr_func_type = FunctionType::get(
++      getInt64Ty(), { dst->getType(), getInt32Ty(), src->getType() }, false);
++  PointerType *probereadstr_func_ptr_type = PointerType::get(
++      probereadstr_func_type, 0);
++  Constant *probereadstr_callee = ConstantExpr::getCast(
++      Instruction::IntToPtr, getInt64(read_fn), probereadstr_func_ptr_type);
++  CallInst *call = createCall(probereadstr_func_type,
++                              probereadstr_callee,
+                               { dst, size_i32, src },
+                               probeReadHelperName(read_fn));
+   CreateHelperErrorCond(ctx, call, read_fn, loc);
+@@ -732,8 +714,10 @@ Value *IRBuilderBPF::CreateUSDTReadArgument(Value *ctx,
+   return result;
+ }
+ 
+-Value *IRBuilderBPF::CreateStrncmp(Value *val1,
+-                                   Value *val2,
++Value *IRBuilderBPF::CreateStrncmp(Value *str1,
++                                   uint64_t str1_size,
++                                   Value *str2,
++                                   uint64_t str2_size,
+                                    uint64_t n,
+                                    bool inverse)
+ {
+@@ -762,40 +746,21 @@ Value *IRBuilderBPF::CreateStrncmp(Value *val1,
+   // Check if the compared strings are literals.
+   // If so, we can avoid storing the literal in memory.
+   std::optional<std::string> literal1;
+-  if (auto constString1 = dyn_cast<ConstantDataArray>(val1))
++  if (auto constString1 = dyn_cast<ConstantDataArray>(str1))
+     literal1 = constString1->getAsString();
+-  else if (isa<ConstantAggregateZero>(val1))
++  else if (isa<ConstantAggregateZero>(str1))
+     literal1 = "";
+   else
+     literal1 = std::nullopt;
+ 
+   std::optional<std::string> literal2;
+-  if (auto constString2 = dyn_cast<ConstantDataArray>(val2))
++  if (auto constString2 = dyn_cast<ConstantDataArray>(str2))
+     literal2 = constString2->getAsString();
+-  else if (isa<ConstantAggregateZero>(val2))
++  else if (isa<ConstantAggregateZero>(str2))
+     literal2 = "";
+   else
+     literal2 = std::nullopt;
+ 
+-  auto *val1p = dyn_cast<PointerType>(val1->getType());
+-  auto *val2p = dyn_cast<PointerType>(val2->getType());
+-#ifndef NDEBUG
+-  if (!literal1)
+-  {
+-    assert(val1p);
+-    assert(val1p->getPointerElementType()->isArrayTy() &&
+-           val1p->getPointerElementType()->getArrayElementType() ==
+-               getInt8Ty());
+-  }
+-  if (!literal2)
+-  {
+-    assert(val2p);
+-    assert(val2p->getPointerElementType()->isArrayTy() &&
+-           val2p->getPointerElementType()->getArrayElementType() ==
+-               getInt8Ty());
+-  }
+-#endif
+-
+   Function *parent = GetInsertBlock()->getParent();
+   AllocaInst *store = CreateAllocaBPF(getInt1Ty(), "strcmp.result");
+   BasicBlock *str_ne = BasicBlock::Create(module_.getContext(),
+@@ -822,8 +787,8 @@ Value *IRBuilderBPF::CreateStrncmp(Value *val1,
+       l = getInt8(literal1->c_str()[i]);
+     else
+     {
+-      auto *ptr_l = CreateGEP(val1p->getPointerElementType(),
+-                              val1,
++      auto *ptr_l = CreateGEP(ArrayType::get(getInt8Ty(), str1_size),
++                              str1,
+                               { getInt32(0), getInt32(i) });
+       l = CreateLoad(getInt8Ty(), ptr_l);
+     }
+@@ -833,8 +798,8 @@ Value *IRBuilderBPF::CreateStrncmp(Value *val1,
+       r = getInt8(literal2->c_str()[i]);
+     else
+     {
+-      auto *ptr_r = CreateGEP(val2p->getPointerElementType(),
+-                              val2,
++      auto *ptr_r = CreateGEP(ArrayType::get(getInt8Ty(), str2_size),
++                              str2,
+                               { getInt32(0), getInt32(i) });
+       r = CreateLoad(getInt8Ty(), ptr_r);
+     }
+@@ -994,11 +959,9 @@ void IRBuilderBPF::CreateGetCurrentComm(Value *ctx,
+                                         size_t size,
+                                         const location &loc)
+ {
+-  assert(buf->getType()->getPointerElementType()->isArrayTy() &&
+-         buf->getType()->getPointerElementType()->getArrayNumElements() >=
+-             size &&
+-         buf->getType()->getPointerElementType()->getArrayElementType() ==
+-             getInt8Ty());
++  assert(buf->getAllocatedType()->isArrayTy() &&
++         buf->getAllocatedType()->getArrayNumElements() >= size &&
++         buf->getAllocatedType()->getArrayElementType() == getInt8Ty());
+ 
+   // long bpf_get_current_comm(char *buf, int size_of_buf)
+   // Return: 0 on success or negative error
+@@ -1077,7 +1040,7 @@ void IRBuilderBPF::CreateSignal(Value *ctx, Value *sig, const location &loc)
+       Instruction::IntToPtr,
+       getInt64(libbpf::BPF_FUNC_send_signal),
+       signal_func_ptr_type);
+-  CallInst *call = createCall(signal_func, { sig }, "signal");
++  CallInst *call = createCall(signal_func_type, signal_func, { sig }, "signal");
+   CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_send_signal, loc);
+ }
+ 
+@@ -1091,7 +1054,7 @@ void IRBuilderBPF::CreateOverrideReturn(Value *ctx, Value *rc)
+   Constant *override_func = ConstantExpr::getCast(Instruction::IntToPtr,
+       getInt64(libbpf::BPF_FUNC_override_return),
+       override_func_ptr_type);
+-  createCall(override_func, { ctx, rc }, "override");
++  createCall(override_func_type, override_func, { ctx, rc }, "override");
+ }
+ 
+ CallInst *IRBuilderBPF::CreateSkbOutput(Value *skb,
+@@ -1126,7 +1089,8 @@ CallInst *IRBuilderBPF::CreateSkbOutput(Value *skb,
+       Instruction::IntToPtr,
+       getInt64(libbpf::BPF_FUNC_skb_output),
+       skb_output_func_ptr_type);
+-  CallInst *call = createCall(skb_output_func,
++  CallInst *call = createCall(skb_output_func_type,
++                              skb_output_func,
+                               { skb, map_ptr, flags, data, size_val },
+                               "skb_output");
+   return call;
+@@ -1320,7 +1284,8 @@ void IRBuilderBPF::CreateSeqPrintf(Value *ctx,
+                           CreateGEP(getInt64Ty(), meta, getInt64(0)),
+                           "seq");
+ 
+-  CallInst *call = createCall(seq_printf_func,
++  CallInst *call = createCall(seq_printf_func_type,
++                              seq_printf_func,
+                               { seq, fmt, fmt_size, data, data_len },
+                               "seq_printf");
+   CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_seq_printf, loc);
+diff --git a/src/ast/irbuilderbpf.h b/src/ast/irbuilderbpf.h
+index e124911b..c9ffb545 100644
+--- a/src/ast/irbuilderbpf.h
++++ b/src/ast/irbuilderbpf.h
+@@ -90,17 +90,11 @@ public:
+                        AddrSpace as,
+                        const location &loc);
+   CallInst *CreateProbeReadStr(Value *ctx,
+-                               AllocaInst *dst,
++                               Value *dst,
+                                llvm::Value *size,
+                                Value *src,
+                                AddrSpace as,
+                                const location &loc);
+-  CallInst *CreateProbeReadStr(Value *ctx,
+-                               AllocaInst *dst,
+-                               size_t size,
+-                               Value *src,
+-                               AddrSpace as,
+-                               const location &loc);
+   CallInst *CreateProbeReadStr(Value *ctx,
+                                Value *dst,
+                                size_t size,
+@@ -115,7 +109,12 @@ public:
+                                 pid_t pid,
+                                 AddrSpace as,
+                                 const location &loc);
+-  Value *CreateStrncmp(Value *val1, Value *val2, uint64_t n, bool inverse);
++  Value *CreateStrncmp(Value *str1,
++                       uint64_t str1_size,
++                       Value *str2,
++                       uint64_t str2_size,
++                       uint64_t n,
++                       bool inverse);
+   CallInst *CreateGetNs(bool boot_time, const location &loc);
+   CallInst *CreateGetPidTgid(const location &loc);
+   CallInst *CreateGetCurrentCgroupId(const location &loc);
+@@ -131,7 +130,10 @@ public:
+                              ArrayRef<Value *> args,
+                              const Twine &Name,
+                              const location *loc = nullptr);
+-  CallInst   *createCall(Value *callee, ArrayRef<Value *> args, const Twine &Name);
++  CallInst *createCall(FunctionType *callee_type,
++                       Value *callee,
++                       ArrayRef<Value *> args,
++                       const Twine &Name);
+   void        CreateGetCurrentComm(Value *ctx, AllocaInst *buf, size_t size, const location& loc);
+   void CreatePerfEventOutput(Value *ctx,
+                              Value *data,
+@@ -185,9 +187,6 @@ private:
+                                 AddrSpace as,
+                                 const location &loc);
+   CallInst *createMapLookup(int mapid, Value *key);
+-  Constant *createProbeReadStrFn(llvm::Type *dst,
+-                                 llvm::Type *src,
+-                                 AddrSpace as);
+   libbpf::bpf_func_id selectProbeReadHelper(AddrSpace as, bool str);
+ 
+   std::map<std::string, StructType *> structs_;
+diff --git a/src/ast/passes/codegen_llvm.cpp b/src/ast/passes/codegen_llvm.cpp
+index a818ca0b..2b888087 100644
+--- a/src/ast/passes/codegen_llvm.cpp
++++ b/src/ast/passes/codegen_llvm.cpp
+@@ -1133,8 +1133,12 @@ void CodegenLLVM::visit(Call &call)
+     auto left_string = getString(left_arg);
+     auto right_string = getString(right_arg);
+ 
+-    expr_ = b_.CreateStrncmp(
+-        left_string.first, right_string.first, size, false);
++    expr_ = b_.CreateStrncmp(left_string.first,
++                             left_string.second,
++                             right_string.first,
++                             right_string.second,
++                             size,
++                             false);
+   }
+   else if (call.func == "override")
+   {
+@@ -1269,8 +1273,7 @@ void CodegenLLVM::visit(Variable &var)
+   else
+   {
+     auto *var_alloca = variables_[var.ident];
+-    expr_ = b_.CreateLoad(var_alloca->getType()->getPointerElementType(),
+-                          var_alloca);
++    expr_ = b_.CreateLoad(var_alloca->getAllocatedType(), var_alloca);
+   }
+ }
+ 
+@@ -1310,7 +1313,12 @@ void CodegenLLVM::binop_string(Binop &binop)
+   auto right_string = getString(binop.right);
+ 
+   size_t len = std::min(left_string.second, right_string.second);
+-  expr_ = b_.CreateStrncmp(left_string.first, right_string.first, len, inverse);
++  expr_ = b_.CreateStrncmp(left_string.first,
++                           left_string.second,
++                           right_string.first,
++                           right_string.second,
++                           len,
++                           inverse);
+ }
+ 
+ void CodegenLLVM::binop_buf(Binop &binop)
+@@ -1334,7 +1342,12 @@ void CodegenLLVM::binop_buf(Binop &binop)
+ 
+   size_t len = std::min(binop.left->type.GetSize(),
+                         binop.right->type.GetSize());
+-  expr_ = b_.CreateStrncmp(left_string, right_string, len, inverse);
++  expr_ = b_.CreateStrncmp(left_string,
++                           binop.left->type.GetSize(),
++                           right_string,
++                           binop.right->type.GetSize(),
++                           len,
++                           inverse);
+ }
+ 
+ void CodegenLLVM::binop_int(Binop &binop)
+@@ -3528,9 +3541,8 @@ void CodegenLLVM::createIncDec(Unop &unop)
+   else if (unop.expr->is_variable)
+   {
+     Variable &var = static_cast<Variable &>(*unop.expr);
+-    Value *oldval = b_.CreateLoad(
+-        variables_[var.ident]->getType()->getPointerElementType(),
+-        variables_[var.ident]);
++    Value *oldval = b_.CreateLoad(variables_[var.ident]->getAllocatedType(),
++                                  variables_[var.ident]);
+     Value *newval;
+     if (is_increment)
+       newval = b_.CreateAdd(oldval, b_.GetIntSameSize(step, oldval));
+-- 
+2.38.1
+

SOURCES/bpftrace-0.16.0-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch

@@ -1,7 +1,7 @@
-From e9ebda9b3d14831df5e1c5174d21f322e084d074 Mon Sep 17 00:00:00 2001
+From 7598b2b918835ab71e48bd7617812bde3a2537a7 Mon Sep 17 00:00:00 2001
 From: Jerome Marchand <jmarchan@redhat.com>
 Date: Thu, 11 Jun 2020 14:56:36 +0200
-Subject: [PATCH] RHEL-8: aarch64: fixes statsnoop and opensnoop
+Subject: [PATCH 4/6] RHEL-8: aarch64: fixes statsnoop and opensnoop
 
 On aarch64 the open syscall has been dropped. Only openat remains,
 wich is called by libc open() function.
@@ -18,7 +18,7 @@ patches.
  2 files changed, 2 insertions(+), 8 deletions(-)
 
 diff --git a/tools/opensnoop.bt b/tools/opensnoop.bt
-index a7de802..d99db93 100755
+index a7de8026..d99db93e 100755
 --- a/tools/opensnoop.bt
 +++ b/tools/opensnoop.bt
 @@ -21,13 +21,11 @@ BEGIN
@@ -36,7 +36,7 @@ index a7de802..d99db93 100755
  /@filename[tid]/
  {
 diff --git a/tools/statsnoop.bt b/tools/statsnoop.bt
-index b2d529e..f612ea9 100755
+index b2d529e2..f612ea94 100755
 --- a/tools/statsnoop.bt
 +++ b/tools/statsnoop.bt
 @@ -30,17 +30,13 @@ tracepoint:syscalls:sys_enter_statfs
@@ -60,5 +60,5 @@ index b2d529e..f612ea9 100755
  {
  	$ret = args->ret;
 -- 
-2.25.4
+2.35.3
 

SOURCES/bpftrace-0.16.0-RHEL8-remove-not-existing-attachpoints-from-tools.patch

@@ -0,0 +1,82 @@
+From 7e813d0e3048f52781199384a120f5e5cbad22ae Mon Sep 17 00:00:00 2001
+From: Viktor Malik <viktor.malik@gmail.com>
+Date: Mon, 5 Dec 2022 13:31:25 +0100
+Subject: [PATCH] RHEL8: remove not existing attachpoints from tools
+
+tools/bio* attempt to attach each probe to multiple kprobes to cover all
+possible systems. Remove probes which do not exist in RHEL8 to remove
+unnecessary warnings.
+---
+ tools/biolatency.bt   | 6 ++----
+ tools/biostacks.bt    | 4 +---
+ tools/old/biosnoop.bt | 6 ++----
+ 3 files changed, 5 insertions(+), 11 deletions(-)
+
+diff --git a/tools/biolatency.bt b/tools/biolatency.bt
+index d5af1f29..4ea910b4 100755
+--- a/tools/biolatency.bt
++++ b/tools/biolatency.bt
+@@ -16,14 +16,12 @@ BEGIN
+ 	printf("Tracing block device I/O... Hit Ctrl-C to end.\n");
+ }
+ 
+-kprobe:blk_account_io_start,
+-kprobe:__blk_account_io_start
++kprobe:blk_account_io_start
+ {
+ 	@start[arg0] = nsecs;
+ }
+ 
+-kprobe:blk_account_io_done,
+-kprobe:__blk_account_io_done
++kprobe:blk_account_io_done
+ /@start[arg0]/
+ {
+ 	@usecs = hist((nsecs - @start[arg0]) / 1000);
+diff --git a/tools/biostacks.bt b/tools/biostacks.bt
+index 1bc9f819..80d8cb9e 100755
+--- a/tools/biostacks.bt
++++ b/tools/biostacks.bt
+@@ -18,14 +18,12 @@ BEGIN
+ 	printf("Tracing block I/O with init stacks. Hit Ctrl-C to end.\n");
+ }
+ 
+-kprobe:blk_account_io_start,
+-kprobe:__blk_account_io_start
++kprobe:blk_account_io_start
+ {
+ 	@reqstack[arg0] = kstack;
+ 	@reqts[arg0] = nsecs;
+ }
+ 
+-kprobe:blk_start_request,
+ kprobe:blk_mq_start_request
+ /@reqts[arg0]/
+ {
+diff --git a/tools/old/biosnoop.bt b/tools/old/biosnoop.bt
+index 1a99643a..327251e3 100755
+--- a/tools/old/biosnoop.bt
++++ b/tools/old/biosnoop.bt
+@@ -22,8 +22,7 @@ BEGIN
+ 	printf("%-12s %-7s %-16s %-6s %7s\n", "TIME(ms)", "DISK", "COMM", "PID", "LAT(ms)");
+ }
+ 
+-kprobe:blk_account_io_start,
+-kprobe:__blk_account_io_start
++kprobe:blk_account_io_start
+ {
+ 	@start[arg0] = nsecs;
+ 	@iopid[arg0] = pid;
+@@ -31,8 +30,7 @@ kprobe:__blk_account_io_start
+ 	@disk[arg0] = ((struct request *)arg0)->rq_disk->disk_name;
+ }
+ 
+-kprobe:blk_account_io_done,
+-kprobe:__blk_account_io_done
++kprobe:blk_account_io_done
+ /@start[arg0] != 0 && @iopid[arg0] != 0 && @iocomm[arg0] != ""/
+ 
+ {
+-- 
+2.38.1
+

SOURCES/bpftrace-0.16.0-cmake-Raise-max-llvm-major-version-to-16.patch

@@ -0,0 +1,26 @@
+From b74ab9e00b4628e0d8607c6ead8a674bedf280b9 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Fri, 10 Mar 2023 00:08:27 -0800
+Subject: [PATCH] cmake: Raise max llvm major version to 16
+
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ CMakeLists.txt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index e63bc83c..433153be 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -169,7 +169,7 @@ else()
+   endif()
+ 
+   set(MIN_LLVM_MAJOR 6)
+-  set(MAX_LLVM_MAJOR 15)
++  set(MAX_LLVM_MAJOR 16)
+ 
+   if((${LLVM_VERSION_MAJOR} VERSION_LESS ${MIN_LLVM_MAJOR}) OR (${LLVM_VERSION_MAJOR} VERSION_GREATER ${MAX_LLVM_MAJOR}))
+     message(SEND_ERROR "Unsupported LLVM version found via ${LLVM_INCLUDE_DIRS}: ${LLVM_VERSION_MAJOR}")
+-- 
+2.40.1
+

SOURCES/bpftrace-0.16.0-tcpdrop-Fix-ERROR-Error-attaching-probe-kprobe-tcp_d.patch

@@ -0,0 +1,173 @@
+From e661f2a043f8b6548e0bb3e0cc5992d7c0ff3b0f Mon Sep 17 00:00:00 2001
+From: Rong Tao <rongtao@cestc.cn>
+Date: Sat, 1 Oct 2022 16:15:27 +0800
+Subject: [PATCH] tcpdrop: Fix: ERROR: Error attaching probe: 'kprobe:tcp_drop'
+
+kernel commit 8fbf195798b5('tcp_drop() is no longer needed.') remove
+the kprobe:tcp_drop, bcc commit 16eab39171eb('Add
+tracepoint:skb:kfree_skb if no tcp_drop() kprobe.') already fix this
+problem.
+
+CI old kernel is too old and not support the 'reason' field, move the
+old tools/tcpdrop.bt into tools/old/tcpdrop.bt and set the CI to use
+it.
+
+Since 5.17 support trace_kfree_skb(skb, ..., reason) 'reason' field.
+Since 5.19 remove tcp_drop() function.
+
+ERROR log:
+
+ $ sudo ./tcpdrop.bt
+ ./tcpdrop.bt:49-51: WARNING: tcp_drop is not traceable (either non-existing, inlined, or marked as "notrace"); attaching to it will likely fail
+ Attaching 3 probes...
+ cannot attach kprobe, probe entry may not exist
+ ERROR: Error attaching probe: 'kprobe:tcp_drop'
+
+Link: https://github.com/iovisor/bpftrace/pull/2379
+Signed-off-by: Rong Tao <rongtao@cestc.cn>
+---
+ tools/old/tcpdrop.bt | 85 ++++++++++++++++++++++++++++++++++++++++++++
+ tools/tcpdrop.bt     | 22 ++++++------
+ 2 files changed, 97 insertions(+), 10 deletions(-)
+ create mode 100755 tools/old/tcpdrop.bt
+
+diff --git a/tools/old/tcpdrop.bt b/tools/old/tcpdrop.bt
+new file mode 100755
+index 00000000..685a5f6a
+--- /dev/null
++++ b/tools/old/tcpdrop.bt
+@@ -0,0 +1,85 @@
++#!/usr/bin/env bpftrace
++/*
++ * tcpdrop.bt   Trace TCP kernel-dropped packets/segments.
++ *              For Linux, uses bpftrace and eBPF.
++ *
++ * USAGE: tcpdrop.bt
++ *
++ * This is a bpftrace version of the bcc tool of the same name.
++ * It is limited to ipv4 addresses, and cannot show tcp flags.
++ *
++ * This provides information such as packet details, socket state, and kernel
++ * stack trace for packets/segments that were dropped via tcp_drop().
++
++ * WARNING: this script attaches to the tcp_drop kprobe which is likely inlined
++ *          on newer kernels and not replaced by anything else, therefore
++ *          the script will stop working
++ *
++ * For Linux <= 5.18.
++ *
++ * Copyright (c) 2018 Dale Hamel.
++ * Licensed under the Apache License, Version 2.0 (the "License")
++ *
++ * 23-Nov-2018	Dale Hamel	created this.
++ */
++
++#ifndef BPFTRACE_HAVE_BTF
++#include <linux/socket.h>
++#include <net/sock.h>
++#else
++#include <sys/socket.h>
++#endif
++
++BEGIN
++{
++  printf("Tracing tcp drops. Hit Ctrl-C to end.\n");
++  printf("%-8s %-8s %-16s %-21s %-21s %-8s\n", "TIME", "PID", "COMM", "SADDR:SPORT", "DADDR:DPORT", "STATE");
++
++  // See https://github.com/torvalds/linux/blob/master/include/net/tcp_states.h
++  @tcp_states[1] = "ESTABLISHED";
++  @tcp_states[2] = "SYN_SENT";
++  @tcp_states[3] = "SYN_RECV";
++  @tcp_states[4] = "FIN_WAIT1";
++  @tcp_states[5] = "FIN_WAIT2";
++  @tcp_states[6] = "TIME_WAIT";
++  @tcp_states[7] = "CLOSE";
++  @tcp_states[8] = "CLOSE_WAIT";
++  @tcp_states[9] = "LAST_ACK";
++  @tcp_states[10] = "LISTEN";
++  @tcp_states[11] = "CLOSING";
++  @tcp_states[12] = "NEW_SYN_RECV";
++}
++
++kprobe:tcp_drop
++{
++  $sk = ((struct sock *) arg0);
++  $inet_family = $sk->__sk_common.skc_family;
++
++  if ($inet_family == AF_INET || $inet_family == AF_INET6) {
++    if ($inet_family == AF_INET) {
++      $daddr = ntop($sk->__sk_common.skc_daddr);
++      $saddr = ntop($sk->__sk_common.skc_rcv_saddr);
++    } else {
++      $daddr = ntop($sk->__sk_common.skc_v6_daddr.in6_u.u6_addr8);
++      $saddr = ntop($sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr8);
++    }
++    $lport = $sk->__sk_common.skc_num;
++    $dport = $sk->__sk_common.skc_dport;
++
++    // Destination port is big endian, it must be flipped
++    $dport = bswap($dport);
++
++    $state = $sk->__sk_common.skc_state;
++    $statestr = @tcp_states[$state];
++
++    time("%H:%M:%S ");
++    printf("%-8d %-16s ", pid, comm);
++    printf("%39s:%-6d %39s:%-6d %-10s\n", $saddr, $lport, $daddr, $dport, $statestr);
++    printf("%s\n", kstack);
++  }
++}
++
++END
++{
++  clear(@tcp_states);
++}
+diff --git a/tools/tcpdrop.bt b/tools/tcpdrop.bt
+index 3450a533..bb31107f 100755
+--- a/tools/tcpdrop.bt
++++ b/tools/tcpdrop.bt
+@@ -9,16 +9,15 @@
+  * It is limited to ipv4 addresses, and cannot show tcp flags.
+  *
+  * This provides information such as packet details, socket state, and kernel
+- * stack trace for packets/segments that were dropped via tcp_drop().
+-
+- * WARNING: this script attaches to the tcp_drop kprobe which is likely inlined
+- *          on newer kernels and not replaced by anything else, therefore
+- *          the script will stop working
+-
++ * stack trace for packets/segments that were dropped via kfree_skb.
++ *
++ * For Linux 5.17+ (see tools/old for script for lower versions).
++ *
+  * Copyright (c) 2018 Dale Hamel.
+  * Licensed under the Apache License, Version 2.0 (the "License")
+-
++ *
+  * 23-Nov-2018	Dale Hamel	created this.
++ * 01-Oct-2022	Rong Tao	use tracepoint:skb:kfree_skb
+  */
+ 
+ #ifndef BPFTRACE_HAVE_BTF
+@@ -48,12 +47,15 @@ BEGIN
+   @tcp_states[12] = "NEW_SYN_RECV";
+ }
+ 
+-kprobe:tcp_drop
++tracepoint:skb:kfree_skb
+ {
+-  $sk = ((struct sock *) arg0);
++  $reason = args->reason;
++  $skb = (struct sk_buff *)args->skbaddr;
++  $sk = ((struct sock *) $skb->sk);
+   $inet_family = $sk->__sk_common.skc_family;
+ 
+-  if ($inet_family == AF_INET || $inet_family == AF_INET6) {
++  if ($reason > SKB_DROP_REASON_NOT_SPECIFIED &&
++      ($inet_family == AF_INET || $inet_family == AF_INET6)) {
+     if ($inet_family == AF_INET) {
+       $daddr = ntop($sk->__sk_common.skc_daddr);
+       $saddr = ntop($sk->__sk_common.skc_rcv_saddr);
+-- 
+2.38.1
+

SOURCES/bpftrace-0.16.0-tools-old-mdflush.bt-fix-BPFTRACE_HAVE_BTF-macro.patch

@@ -0,0 +1,27 @@
+From 31a42a47b90f97a2a8c2446101c0007cf09288bc Mon Sep 17 00:00:00 2001
+From: Viktor Malik <viktor.malik@gmail.com>
+Date: Mon, 5 Dec 2022 11:57:24 +0100
+Subject: [PATCH] tools/old/mdflush.bt: fix BPFTRACE_HAVE_BTF macro
+
+The correct macro to use is called BPFTRACE_HAVE_BTF, not
+__BPFTRACE_HAVE_BTF.
+---
+ tools/old/mdflush.bt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/tools/old/mdflush.bt b/tools/old/mdflush.bt
+index 921c8f1b..23c7dd51 100755
+--- a/tools/old/mdflush.bt
++++ b/tools/old/mdflush.bt
+@@ -15,7 +15,7 @@
+  * 08-Sep-2018	Brendan Gregg	Created this.
+  */
+ 
+-#ifndef __BPFTRACE_HAVE_BTF
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/genhd.h>
+ #include <linux/bio.h>
+ #endif
+-- 
+2.38.1
+

SPECS/bpftrace.spec

@@ -1,19 +1,26 @@
 %bcond_without llvm_static
 
 Name:           bpftrace
-Version:        0.10.0
-Release:        4%{?dist}
+Version:        0.16.0
+Release:        5%{?dist}
 Summary:        High-level tracing language for Linux eBPF
 License:        ASL 2.0
 
+%define cereal_version 1.3.2
+
 URL:            https://github.com/iovisor/bpftrace
 Source0:        %{url}/archive/v%{version}/%{name}-%{version}.tar.gz
-Patch0:         %{name}-%{version}-RHEL-8-fixes.patch
-Patch1:         %{name}-%{version}-Add-s390x-register-support.patch
-Patch2:         %{name}-%{version}-Remove-RLIMIT_AS-limit.patch
-Patch3:         %{name}-%{version}-Fix-KBUILD_MODNAME.patch
-# WARNING: because of the arch-specific patch, no autosetup is used
-# Remember to patch accordingly
+# Cereal is a header-only serialization library which is not packaged into
+# RHEL8, so we download it manually. This is ok to do as it is only necessary
+# for build.
+Source1:        https://github.com/USCiLab/cereal/archive/v%{cereal_version}/cereal-%{cereal_version}.tar.gz
+
+Patch0:         %{name}-%{version}-IR-builder-get-rid-of-getPointerElementType-calls.patch
+Patch1:         %{name}-%{version}-tools-old-mdflush.bt-fix-BPFTRACE_HAVE_BTF-macro.patch
+Patch2:         %{name}-%{version}-tcpdrop-Fix-ERROR-Error-attaching-probe-kprobe-tcp_d.patch
+Patch3:         %{name}-%{version}-RHEL8-remove-not-existing-attachpoints-from-tools.patch
+Patch4:         %{name}-%{version}-cmake-Raise-max-llvm-major-version-to-16.patch
+Patch5:         %{name}-%{version}-Adjust-to-build-with-llvm-17.patch
 Patch10:        %{name}-%{version}-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch
 
 # Arches will be included as upstream support is added and dependencies are
@@ -29,11 +36,17 @@ BuildRequires:  zlib-devel
 BuildRequires:  llvm-devel
 BuildRequires:  clang-devel
 BuildRequires:  bcc-devel
+BuildRequires:  libbpf-devel
+BuildRequires:  libbpf-static
+BuildRequires:  binutils-devel
 
 %if %{with llvm_static}
 BuildRequires:  llvm-static
 %endif
 
+# We don't need kernel-devel to use bpftrace, but some tools need it
+Recommends:     kernel-devel
+
 %description
 BPFtrace is a high-level tracing language for Linux enhanced Berkeley Packet
 Filter (eBPF) available in recent Linux kernels (4.x). BPFtrace uses LLVM as a
@@ -45,36 +58,40 @@ and predecessor tracers such as DTrace and SystemTap
 
 
 %prep
-%setup
-
-%patch0 -p1
-%patch1 -p1
-%patch2 -p1
-%patch3 -p1
+%autosetup -N -a 1
+%autopatch -p1 -M 9
 
 %ifarch aarch64
 %patch10 -p1
 %endif
 
 %build
+# Set CPATH so that CMake finds the cereal headers
+CPATH=$PWD/cereal-%{cereal_version}/include:$CPATH
+export CPATH
 %cmake . \
         -DCMAKE_BUILD_TYPE=RelWithDebInfo \
         -DBUILD_TESTING:BOOL=OFF \
         -DBUILD_SHARED_LIBS:BOOL=OFF
-#        -DLLVM_DIR=/usr/lib64/llvm7.0/lib/cmake/llvm/
 %make_build
 
 
 %install
+# The post hooks strip the binary which removes
+# the BEGIN_trigger and END_trigger functions
+# which are needed for the BEGIN and END probes
+%global __os_install_post %{nil}
+%global _find_debuginfo_opts -g
+
 %make_install
 
 # Fix shebangs (https://fedoraproject.org/wiki/Packaging:Guidelines#Shebang_lines)
 find %{buildroot}%{_datadir}/%{name}/tools -type f -exec \
   sed -i -e '1s=^#!/usr/bin/env %{name}\([0-9.]\+\)\?$=#!%{_bindir}/%{name}=' {} \;
 
-# Move man pages to the right location
-#mkdir -p %{buildroot}%{_mandir}
-#mv %{buildroot}%{_prefix}/man/* %{buildroot}%{_mandir}/
+# Some tools require old versions for RHEL8
+cp %{buildroot}/%{_datadir}/%{name}/tools/old/biosnoop.bt %{buildroot}/%{_datadir}/%{name}/tools
+cp %{buildroot}/%{_datadir}/%{name}/tools/old/mdflush.bt %{buildroot}/%{_datadir}/%{name}/tools
 
 
 %files
@@ -84,18 +101,63 @@ find %{buildroot}%{_datadir}/%{name}/tools -type f -exec \
 %dir %{_datadir}/%{name}
 %dir %{_datadir}/%{name}/tools
 %dir %{_datadir}/%{name}/tools/doc
+%dir %{_datadir}/%{name}/tools/old
 %{_bindir}/%{name}
+%{_bindir}/%{name}-aotrt
 %{_mandir}/man8/*
 %attr(0755,-,-) %{_datadir}/%{name}/tools/*.bt
 %{_datadir}/%{name}/tools/doc/*.txt
-# tcp_drop() is inlined on ppc64
-%ifarch %{power64}
-%exclude %{_datadir}/%{name}/tools/tcpdrop.bt
-%exclude %{_datadir}/%{name}/tools/doc/tcpdrop_example.txt
-%exclude %{_mandir}/man8/tcpdrop.8.gz
-%endif
+# Do not include old versions of tools.
+# Those that are needed were already installed as normal tools.
+%exclude %{_datadir}/%{name}/tools/old
 
 %changelog
+* Mon Nov 06 2023  - 0.16.0-5
+- Rebuild for LLVM17
+- Resolves: RHEL-10690
+
+* Fri Jun 09 2023 Viktor Malik <vmalik@redhat.com> - 0.16.0-3
+- Add forgotten patch raising LLVM version in CMake
+- Resolves: rhbz#2192950
+
+* Fri Jun 09 2023 Viktor Malik <vmalik@redhat.com> - 0.16.0-2
+- Rebuild for LLVM16
+- Resolves: rhbz#2192950
+
+* Wed Nov 30 2022 Viktor Malik <vmalik@redhat.com> - 0.16.0-1
+- Rebase on bpftrace 0.16.0
+- Rebuild for LLVM15
+- Download the cereal library (not packaged into RHEL8)
+
+* Thu Jun 02 2022 Jerome Marchand <jmarchan@redhat.com> - 0.13.1-1
+- Rebase on bpftrace 0.13.1
+- Rebuild on LLVM14
+
+* Thu Dec 02 2021 Jerome Marchand <jmarchan@redhat.com> - 0.12.1-4
+- Rebuild on LLVM13
+- Small spec cleanup
+
+* Thu Jun 24 2021 Jerome Marchand <jmarchan@redhat.com> - 0.12.1-3
+- Have threadsnoop points to libpthread.so.0
+
+* Wed Jun 09 2021 Jerome Marchand <jmarchan@redhat.com> - 0.12.1-2
+- Rebuild on LLVM12
+
+* Fri Apr 30 2021 Jerome Marchand <jmarchan@redhat.com> - 0.12.1-1
+- Rebase on bpftrace 0.12.1
+
+* Thu Jan 28 2021 Jerome Marchand <jmarchan@redhat.com> - 0.11.1-3
+- Add missing libbpf and binutils-dev dependencies
+
+* Wed Nov 11 2020 Jerome Marchand <jmarchan@redhat.com> - 0.11.1-2
+- Fix statsnoop and opensnoop on aarch64 again
+
+* Fri Nov 06 2020 Jerome Marchand <jmarchan@redhat.com> - 0.11.1-1
+- Rebase on bpftrace 0.11.1
+
+* Tue Oct 27 2020 Jerome Marchand <jmarchan@redhat.com> - 0.10.0-5
+- Rebuild for bcc 0.16.0
+
 * Thu Jun 11 2020 Jerome Marchand <jmarchan@redhat.com> - 0.10.0-4
 - Fix KBUILD_MODNAME