diff --git a/1001-bpftrace-anolis-fix-build-failed-on-aarch64.patch b/1001-bpftrace-anolis-fix-build-failed-on-aarch64.patch new file mode 100644 index 0000000000000000000000000000000000000000..c15dd4f6a26bcb216234924dceef57537b10101f --- /dev/null +++ b/1001-bpftrace-anolis-fix-build-failed-on-aarch64.patch @@ -0,0 +1,87 @@ +From 330953c11190c23a12f98d374d1b5eb6d7aad1fe Mon Sep 17 00:00:00 2001 +From: Chunmei Xu +Date: Wed, 11 Nov 2020 16:23:19 +0800 +Subject: [PATCH] fix build failed on aarch64 + +since linux has drop __NR_open on aarch64, syscall.c will build +failed on aarch64 without __NR_open defined. + +Signed-off-by: Chunmei Xu +--- + tests/testprogs/syscall.c | 31 ++++++++++++++++++++++++------- + 1 file changed, 24 insertions(+), 7 deletions(-) + +diff --git a/tests/testprogs/syscall.c b/tests/testprogs/syscall.c +index c212466..ca1f699 100644 +--- a/tests/testprogs/syscall.c ++++ b/tests/testprogs/syscall.c +@@ -15,7 +15,9 @@ void usage() + printf("\t./syscall []\n"); + printf("Supported Syscalls:\n"); + printf("\t nanosleep [$N] (default args: 100ns)\n"); ++#if defined(SYS_open) + printf("\t open\n"); ++#endif + printf("\t openat\n"); + printf("\t read\n"); + printf("\t execve [] (at most 128 arguments)\n"); +@@ -82,8 +84,19 @@ int gen_open_openat(bool is_sys_open) + { + char *file_path = get_tmp_file_path( + "/bpftrace_runtime_test_syscall_gen_open_temp"); +- int fd = is_sys_open ? syscall(SYS_open, file_path, O_CREAT) +- : syscall(SYS_openat, AT_FDCWD, file_path, O_CREAT); ++ int fd = -1; ++ ++ if (is_sys_open) ++ { ++#if defined(SYS_open) ++ fd = syscall(SYS_open, file_path, O_CREAT); ++#endif ++ } ++ else ++ { ++ fd = syscall(SYS_openat, AT_FDCWD, file_path, O_CREAT); ++ } ++ + if (fd < 0) + { + perror("Error in syscall open/openat"); +@@ -154,7 +167,6 @@ int main(int argc, char *argv[]) + return 1; + } + const char *syscall_name = argv[1]; +- bool is_sys_open = false; + int r = 0; + + if (strcmp("--help", syscall_name) == 0 || strcmp("-h", syscall_name) == 0) +@@ -165,11 +177,16 @@ int main(int argc, char *argv[]) + { + r = gen_nanosleep(argc, argv); + } +- else if ((is_sys_open = (strcmp("open", syscall_name) == 0)) || +- strcmp("openat", syscall_name) == 0) ++ else if (strcmp("openat", syscall_name) == 0) + { +- r = gen_open_openat(is_sys_open); ++ r = gen_open_openat(false); + } ++#if defined(SYS_open) ++ else if (strcmp("open", syscall_name) == 0) ++ { ++ r = gen_open_openat(true); ++ } ++#endif + else if (strcmp("read", syscall_name) == 0) + { + r = gen_read(); +@@ -186,4 +203,4 @@ int main(int argc, char *argv[]) + } + + return r; +-} +\ No newline at end of file ++} +-- +2.19.1.6.gb485710b + diff --git a/1002-bpftrace-anolis-tests-Add-architecture-specific-testcase-support.patch b/1002-bpftrace-anolis-tests-Add-architecture-specific-testcase-support.patch new file mode 100644 index 0000000000000000000000000000000000000000..a225a20d62a0ed00c35c6b83f2bbcb2b9ca918ae --- /dev/null +++ b/1002-bpftrace-anolis-tests-Add-architecture-specific-testcase-support.patch @@ -0,0 +1,130 @@ +From 2aa294b12568978eca1251100e149e830b23c097 Mon Sep 17 00:00:00 2001 +From: Jeffle Xu +Date: Mon, 26 Oct 2020 22:19:11 +0800 +Subject: [PATCH] tests: Add architecture specific testcase support + +commit 48d405133160 ("bpftrace: Add architecture specific testcase +support") added architecture specific support for runtime tests. +Still there are architecture specific testcases in semantic_analyser, +where 'ip' register is hard coded in semantic_analyser.call_reg and +semantic_analyser.builtin_functions. + +Besides registers such as 'ip' and 'bp' are also hard codes in some +codegen tests. + +These testcases are all c/c++ files and thus we need conditional compiling. + +Signed-off-by: Jeffle Xu +--- + tests/CMakeLists.txt | 12 ++++++++++++ + tests/codegen/call_reg.cpp | 2 ++ + tests/codegen/intptrcast_assign_var.cpp | 2 ++ + tests/codegen/intptrcast_call.cpp | 2 ++ + tests/semantic_analyser.cpp | 4 ++++ + 5 files changed, 22 insertions(+) + +diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt +index 332eba2..3b843e7 100644 +--- a/tests/CMakeLists.txt ++++ b/tests/CMakeLists.txt +@@ -108,6 +108,18 @@ if(HAVE_BFD_DISASM) + endif(STATIC_LINKING) + endif(HAVE_BFD_DISASM) + ++if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") ++ target_compile_definitions(bpftrace_test PRIVATE ARCH_AARCH64) ++elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64" OR ++ CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64le") ++ target_compile_definitions(bpftrace_test PRIVATE ARCH_PPC64) ++elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "s390" OR ++ CMAKE_SYSTEM_PROCESSOR STREQUAL "s390x") ++ target_compile_definitions(bpftrace_test PRIVATE ARCH_S390) ++elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") ++ target_compile_definitions(bpftrace_test PRIVATE ARCH_X86_64) ++endif() ++ + target_link_libraries(bpftrace_test arch ast parser resources) + + target_link_libraries(bpftrace_test ${LIBBCC_LIBRARIES}) +diff --git a/tests/codegen/call_reg.cpp b/tests/codegen/call_reg.cpp +index 3f4c790..c660451 100644 +--- a/tests/codegen/call_reg.cpp ++++ b/tests/codegen/call_reg.cpp +@@ -4,12 +4,14 @@ namespace bpftrace { + namespace test { + namespace codegen { + ++#ifdef ARCH_X86_64 + TEST(codegen, call_reg) // Identical to builtin_func apart from variable names + { + test("kprobe:f { @x = reg(\"ip\") }", + + NAME); + } ++#endif + + } // namespace codegen + } // namespace test +diff --git a/tests/codegen/intptrcast_assign_var.cpp b/tests/codegen/intptrcast_assign_var.cpp +index a536a90..53e4a5a 100644 +--- a/tests/codegen/intptrcast_assign_var.cpp ++++ b/tests/codegen/intptrcast_assign_var.cpp +@@ -4,10 +4,12 @@ namespace bpftrace { + namespace test { + namespace codegen { + ++#ifdef ARCH_X86_64 + TEST(codegen, intptrcast_assign_var) + { + test("kretprobe:f { @=*(int8*)(reg(\"bp\")-1) }", NAME); + } ++#endif + + } // namespace codegen + } // namespace test +diff --git a/tests/codegen/intptrcast_call.cpp b/tests/codegen/intptrcast_call.cpp +index 70e73ea..5ccceae 100644 +--- a/tests/codegen/intptrcast_call.cpp ++++ b/tests/codegen/intptrcast_call.cpp +@@ -4,11 +4,13 @@ namespace bpftrace { + namespace test { + namespace codegen { + ++#ifdef ARCH_X86_64 + TEST(codegen, intptrcast_call) + { + // Casting should work inside a call + test("kretprobe:f { @=sum(*(int8*)(reg(\"bp\")-1)) }", NAME); + } ++#endif + + } // namespace codegen + } // namespace test +diff --git a/tests/semantic_analyser.cpp b/tests/semantic_analyser.cpp +index b51313a..e7345c3 100644 +--- a/tests/semantic_analyser.cpp ++++ b/tests/semantic_analyser.cpp +@@ -188,7 +188,9 @@ TEST(semantic_analyser, builtin_functions) + test("kprobe:f { kaddr(\"sym\") }", 0); + test("kprobe:f { ntop(0xffff) }", 0); + test("kprobe:f { ntop(2, 0xffff) }", 0); ++#ifdef ARCH_X86_64 + test("kprobe:f { reg(\"ip\") }", 0); ++#endif + test("kprobe:f { kstack(1) }", 0); + test("kprobe:f { ustack(1) }", 0); + test("kprobe:f { cat(\"/proc/uptime\") }", 0); +@@ -684,8 +686,10 @@ TEST(semantic_analyser, call_cgroupid) + + TEST(semantic_analyser, call_reg) + { ++#ifdef ARCH_X86_64 + test("kprobe:f { reg(\"ip\"); }", 0); + test("kprobe:f { @x = reg(\"ip\"); }", 0); ++#endif + test("kprobe:f { reg(\"blah\"); }", 1); + test("kprobe:f { reg(); }", 1); + test("kprobe:f { reg(123); }", 1); +-- +2.19.1.6.gb485710b + diff --git a/1003-bpftrace-anolis-tests-fix-semantic_analyser.type_ctx-failed-on-aarch64.patch b/1003-bpftrace-anolis-tests-fix-semantic_analyser.type_ctx-failed-on-aarch64.patch new file mode 100644 index 0000000000000000000000000000000000000000..105508bb02657075c048d1621c8c74d489abe4dc --- /dev/null +++ b/1003-bpftrace-anolis-tests-fix-semantic_analyser.type_ctx-failed-on-aarch64.patch @@ -0,0 +1,52 @@ +From 3ed572dd5564ae043331862a3afc4c1e3843c1db Mon Sep 17 00:00:00 2001 +From: Chunmei Xu +Date: Thu, 24 Dec 2020 09:48:14 +0800 +Subject: [PATCH] tests: fix semantic_analyser.type_ctx failed on aarch64 + +char is default to signed on x86_64, but default to unsigned on aarch64, +powerpc and s390. + +Signed-off-by: Chunmei Xu +--- + tests/semantic_analyser.cpp | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +diff --git a/tests/semantic_analyser.cpp b/tests/semantic_analyser.cpp +index 8ea7028..a7612b6 100644 +--- a/tests/semantic_analyser.cpp ++++ b/tests/semantic_analyser.cpp +@@ -1646,11 +1646,17 @@ TEST(semantic_analyser, type_ctx) + var = static_cast(unop->expr); + EXPECT_EQ(SizedType(Type::ctx, 8, false), var->type); + ++#if ARCH_X86_64 ++ auto chartype = CreateInt8(); ++#else ++ auto chartype = CreateUInt8(); ++#endif ++ + // $c = $x->c.c; + assignment = static_cast(stmts->at(3)); +- EXPECT_EQ(CreateInt8(), assignment->var->type); ++ EXPECT_EQ(chartype, assignment->var->type); + fieldaccess = static_cast(assignment->expr); +- EXPECT_EQ(CreateInt8(), fieldaccess->type); ++ EXPECT_EQ(chartype, fieldaccess->type); + fieldaccess = static_cast(fieldaccess->expr); + EXPECT_EQ(SizedType(Type::ctx, 1, false), fieldaccess->type); + unop = static_cast(fieldaccess->expr); +@@ -1660,9 +1666,9 @@ TEST(semantic_analyser, type_ctx) + + // $d = $x->d->c; + assignment = static_cast(stmts->at(4)); +- EXPECT_EQ(CreateInt8(), assignment->var->type); ++ EXPECT_EQ(chartype, assignment->var->type); + fieldaccess = static_cast(assignment->expr); +- EXPECT_EQ(CreateInt8(), fieldaccess->type); ++ EXPECT_EQ(chartype, fieldaccess->type); + unop = static_cast(fieldaccess->expr); + EXPECT_EQ(CreateCast(8), unop->type); + fieldaccess = static_cast(unop->expr); +-- +2.18.1 + diff --git a/1004-bpftrace-anolis-tests-childproc-resume-SIGHUP-to-SIG_DFL-before-test.patch b/1004-bpftrace-anolis-tests-childproc-resume-SIGHUP-to-SIG_DFL-before-test.patch new file mode 100644 index 0000000000000000000000000000000000000000..6dd9f36f95892852d3a6e6379becb3d95395066c --- /dev/null +++ b/1004-bpftrace-anolis-tests-childproc-resume-SIGHUP-to-SIG_DFL-before-test.patch @@ -0,0 +1,28 @@ +From 9458ab3415cd4c7d2476da71def2314da96b6ba8 Mon Sep 17 00:00:00 2001 +From: Chunmei Xu +Date: Wed, 6 Jan 2021 12:38:57 +0800 +Subject: [PATCH] tests/childproc: resume SIGHUP to SIG_DFL before test + +since SIGHUP could be set SIG_IGN in parent process, +test will get failed, so resume SIGHUP before test. + +Signed-off-by: Chunmei Xu +--- + tests/child.cpp | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/tests/child.cpp b/tests/child.cpp +index adab527..8dedca0 100644 +--- a/tests/child.cpp ++++ b/tests/child.cpp +@@ -110,6 +110,7 @@ TEST(childproc, destructor_destroy_child) + + TEST(childproc, child_kill_before_exec) + { ++ signal(SIGHUP, SIG_DFL); + auto child = getChild(TEST_BIN_SLOW); + + EXPECT_EQ(kill(child->pid(), SIGHUP), 0); +-- +2.19.1.6.gb485710b + diff --git a/bpftrace-0.11.1-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch b/bpftrace-0.11.1-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch deleted file mode 100644 index 43b02fa1dea1c8019ad871ce5dc0f8548474f261..0000000000000000000000000000000000000000 --- a/bpftrace-0.11.1-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch +++ /dev/null @@ -1,282 +0,0 @@ -From 0768e5f58d39ebb60c18813ea77953be00ce5830 Mon Sep 17 00:00:00 2001 -From: Ovidiu Panait -Date: Thu, 6 Aug 2020 10:34:23 +0300 -Subject: [PATCH] irbuilderbpf.cpp, bpforc.h: Fix compilation with LLVM 11 -MIME-Version: 1.0 -Content-Type: text/plain; charset=UTF-8 -Content-Transfer-Encoding: 8bit - -Fixes: #1384 - -Fix the following build errors when compiling with LLVM 11: - - #1 ----- -/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h:118:35: error: no match for call to ‘(bpftrace::BpfOrc::BpfOrc(llvm::TargetMachine*)::) (llvm::StringRef)’ - 118 | if (JITSymbol Sym = FindSymbol(*S)) { - | ~~~~~~~~~~^~~~ -/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h:118:35: note: candidate: ‘llvm::JITSymbol (*)(const string&)’ {aka ‘llvm::JITSymbol (*)(const std::__cxx11::basic_string&)’} -/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h:118:35: note: candidate expects 2 arguments, 2 provided -In file included from /work/src/github.com/iovisor/bpftrace/src/ast/codegen_llvm.cpp:5: -/work/src/github.com/iovisor/bpftrace/src/bpforc.h:99:13: note: candidate: ‘bpftrace::BpfOrc::BpfOrc(llvm::TargetMachine*)::’ - 99 | [](const std::string &Name __attribute__((unused))) -> JITSymbol { - | ^ -/work/src/github.com/iovisor/bpftrace/src/bpforc.h:99:13: note: no known conversion for argument 1 from ‘llvm::StringRef’ to ‘const string&’ {aka ‘const std::__cxx11::basic_string&’} -In file included from /llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h:23, - - #2 ----- -| /src/ast/irbuilderbpf.cpp: In member function 'llvm::CallInst* bpftrace::ast::IRBuilderBPF::createMapLookup(int, llvm::AllocaInst*)': -| /src/ast/irbuilderbpf.cpp:230:65: error: no matching function for call to 'bpftrace::ast::IRBuilderBPF::CreateCall(llvm::Constant*&, , const char [12])' -| 230 | return CreateCall(lookup_func, { map_ptr, key }, "lookup_elem"); -| | ^ -| In file included from /src/ast/irbuilderbpf.h:9, -| from /src/ast/async_event_types.h:3, -| from /src/ast/irbuilderbpf.cpp:5: -| /usr/include/llvm/IR/IRBuilder.h:2324:13: note: candidate: 'llvm::CallInst* llvm::IRBuilderBase::CreateCall(llvm::FunctionType*, llvm::Value*, llvm::ArrayRef, const llvm::Twine&, llvm::MDNode*)' -| 2324 | CallInst *CreateCall(FunctionType *FTy, Value *Callee, -| | ^~~~~~~~~~ -| /usr/include/llvm/IR/IRBuilder.h:2324:38: note: no known conversion for argument 1 from 'llvm::Constant*' to 'llvm::FunctionType*' -| 2324 | CallInst *CreateCall(FunctionType *FTy, Value *Callee, -| | ~~~~~~~~~~~~~~^~~ - -The CreateCall part is based on the llvm 11 fix from bcc: -https://github.com/iovisor/bcc/commit/45e63f2b316cdce2d8cc925f6f14a8726ade9ff6 - -Signed-off-by: Ovidiu Panait ---- - src/ast/irbuilderbpf.cpp | 55 ++++++++++++++++++++++++++-------------- - src/ast/irbuilderbpf.h | 1 + - src/bpforc.h | 6 +++++ - 3 files changed, 43 insertions(+), 19 deletions(-) - -diff --git a/src/ast/irbuilderbpf.cpp b/src/ast/irbuilderbpf.cpp -index 8ae055e..4498e0f 100644 ---- a/src/ast/irbuilderbpf.cpp -+++ b/src/ast/irbuilderbpf.cpp -@@ -201,10 +201,25 @@ llvm::Type *IRBuilderBPF::GetType(const SizedType &stype) - return ty; - } - -+CallInst *IRBuilderBPF::createCall(Value *callee, -+ ArrayRef args, -+ const Twine &Name) -+{ -+#if LLVM_VERSION_MAJOR >= 11 -+ auto *calleePtrType = cast(callee->getType()); -+ auto *calleeType = cast(calleePtrType->getElementType()); -+ return CreateCall(calleeType, callee, args, Name); -+#else -+ return CreateCall(callee, args, Name); -+#endif -+} -+ - CallInst *IRBuilderBPF::CreateBpfPseudoCall(int mapfd) - { - Function *pseudo_func = module_.getFunction("llvm.bpf.pseudo"); -- return CreateCall(pseudo_func, {getInt64(BPF_PSEUDO_MAP_FD), getInt64(mapfd)}, "pseudo"); -+ return createCall(pseudo_func, -+ { getInt64(BPF_PSEUDO_MAP_FD), getInt64(mapfd) }, -+ "pseudo"); - } - - CallInst *IRBuilderBPF::CreateBpfPseudoCall(Map &map) -@@ -227,7 +242,7 @@ CallInst *IRBuilderBPF::createMapLookup(int mapfd, AllocaInst *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, { map_ptr, key }, "lookup_elem"); - } - - CallInst *IRBuilderBPF::CreateGetJoinMap(Value *ctx, const location &loc) -@@ -325,7 +340,7 @@ 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, - { map_ptr, key, val, flags }, - "update_elem"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_map_update_elem, loc); -@@ -349,7 +364,7 @@ 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, { map_ptr, key }, "delete_elem"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_map_delete_elem, loc); - } - -@@ -378,7 +393,7 @@ void IRBuilderBPF::CreateProbeRead(Value *ctx, - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_probe_read), - proberead_func_ptr_type); -- CallInst *call = CreateCall(proberead_func, { dst, size, src }, "probe_read"); -+ CallInst *call = createCall(proberead_func, { dst, size, src }, "probe_read"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_probe_read, loc); - } - -@@ -413,7 +428,7 @@ CallInst *IRBuilderBPF::CreateProbeReadStr(Value *ctx, - { - assert(ctx && ctx->getType() == getInt8PtrTy()); - Constant *fn = createProbeReadStrFn(dst->getType(), src->getType()); -- CallInst *call = CreateCall(fn, -+ CallInst *call = createCall(fn, - { dst, getInt32(size), src }, - "probe_read_str"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_probe_read_str, loc); -@@ -434,7 +449,7 @@ CallInst *IRBuilderBPF::CreateProbeReadStr(Value *ctx, - auto *size_i32 = CreateIntCast(size, getInt32Ty(), false); - - Constant *fn = createProbeReadStrFn(dst->getType(), src->getType()); -- CallInst *call = CreateCall(fn, { dst, size_i32, src }, "probe_read_str"); -+ CallInst *call = createCall(fn, { dst, size_i32, src }, "probe_read_str"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_probe_read_str, loc); - return call; - } -@@ -717,7 +732,7 @@ CallInst *IRBuilderBPF::CreateGetNs() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_ktime_get_ns), - gettime_func_ptr_type); -- return CreateCall(gettime_func, {}, "get_ns"); -+ return createCall(gettime_func, {}, "get_ns"); - } - - CallInst *IRBuilderBPF::CreateGetPidTgid() -@@ -730,7 +745,7 @@ CallInst *IRBuilderBPF::CreateGetPidTgid() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_current_pid_tgid), - getpidtgid_func_ptr_type); -- return CreateCall(getpidtgid_func, {}, "get_pid_tgid"); -+ return createCall(getpidtgid_func, {}, "get_pid_tgid"); - } - - CallInst *IRBuilderBPF::CreateGetCurrentCgroupId() -@@ -744,7 +759,7 @@ CallInst *IRBuilderBPF::CreateGetCurrentCgroupId() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_current_cgroup_id), - getcgroupid_func_ptr_type); -- return CreateCall(getcgroupid_func, {}, "get_cgroup_id"); -+ return createCall(getcgroupid_func, {}, "get_cgroup_id"); - } - - CallInst *IRBuilderBPF::CreateGetUidGid() -@@ -757,7 +772,7 @@ CallInst *IRBuilderBPF::CreateGetUidGid() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_current_uid_gid), - getuidgid_func_ptr_type); -- return CreateCall(getuidgid_func, {}, "get_uid_gid"); -+ return createCall(getuidgid_func, {}, "get_uid_gid"); - } - - CallInst *IRBuilderBPF::CreateGetCpuId() -@@ -770,7 +785,7 @@ CallInst *IRBuilderBPF::CreateGetCpuId() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_smp_processor_id), - getcpuid_func_ptr_type); -- return CreateCall(getcpuid_func, {}, "get_cpu_id"); -+ return createCall(getcpuid_func, {}, "get_cpu_id"); - } - - CallInst *IRBuilderBPF::CreateGetCurrentTask() -@@ -783,7 +798,7 @@ CallInst *IRBuilderBPF::CreateGetCurrentTask() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_current_task), - getcurtask_func_ptr_type); -- return CreateCall(getcurtask_func, {}, "get_cur_task"); -+ return createCall(getcurtask_func, {}, "get_cur_task"); - } - - CallInst *IRBuilderBPF::CreateGetRandom() -@@ -796,7 +811,7 @@ CallInst *IRBuilderBPF::CreateGetRandom() - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_prandom_u32), - getrandom_func_ptr_type); -- return CreateCall(getrandom_func, {}, "get_random"); -+ return createCall(getrandom_func, {}, "get_random"); - } - - CallInst *IRBuilderBPF::CreateGetStackId(Value *ctx, -@@ -826,7 +841,7 @@ CallInst *IRBuilderBPF::CreateGetStackId(Value *ctx, - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_stackid), - getstackid_func_ptr_type); -- CallInst *call = CreateCall(getstackid_func, -+ CallInst *call = createCall(getstackid_func, - { ctx, map_ptr, flags_val }, - "get_stackid"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_get_stackid, loc); -@@ -852,7 +867,7 @@ void IRBuilderBPF::CreateGetCurrentComm(Value *ctx, - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_get_current_comm), - getcomm_func_ptr_type); -- CallInst *call = CreateCall(getcomm_func, -+ CallInst *call = createCall(getcomm_func, - { buf, getInt64(size) }, - "get_comm"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_get_current_comm, loc); -@@ -883,7 +898,9 @@ void IRBuilderBPF::CreatePerfEventOutput(Value *ctx, Value *data, size_t size) - Instruction::IntToPtr, - getInt64(libbpf::BPF_FUNC_perf_event_output), - perfoutput_func_ptr_type); -- CreateCall(perfoutput_func, {ctx, map_ptr, flags_val, data, size_val}, "perf_event_output"); -+ createCall(perfoutput_func, -+ { ctx, map_ptr, flags_val, data, size_val }, -+ "perf_event_output"); - } - - void IRBuilderBPF::CreateSignal(Value *ctx, Value *sig, const location &loc) -@@ -899,7 +916,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, { sig }, "signal"); - CreateHelperErrorCond(ctx, call, libbpf::BPF_FUNC_send_signal, loc); - } - -@@ -913,7 +930,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, { ctx, rc }, "override"); - } - - Value *IRBuilderBPF::CreatKFuncArg(Value *ctx, -diff --git a/src/ast/irbuilderbpf.h b/src/ast/irbuilderbpf.h -index d4361a8..3111507 100644 ---- a/src/ast/irbuilderbpf.h -+++ b/src/ast/irbuilderbpf.h -@@ -80,6 +80,7 @@ class IRBuilderBPF : public IRBuilder<> - CallInst *CreateGetRandom(); - CallInst *CreateGetStackId(Value *ctx, bool ustack, StackType stack_type, const location& loc); - CallInst *CreateGetJoinMap(Value *ctx, const location& loc); -+ CallInst *createCall(Value *callee, ArrayRef args, const Twine &Name); - void CreateGetCurrentComm(Value *ctx, AllocaInst *buf, size_t size, const location& loc); - void CreatePerfEventOutput(Value *ctx, Value *data, size_t size); - void CreateSignal(Value *ctx, Value *sig, const location &loc); -diff --git a/src/bpforc.h b/src/bpforc.h -index a42e031..295f703 100644 ---- a/src/bpforc.h -+++ b/src/bpforc.h -@@ -96,9 +96,15 @@ class BpfOrc - : TM(TM_), - Resolver(createLegacyLookupResolver( - ES, -+#if LLVM_VERSION_MAJOR >= 11 -+ [](llvm::StringRef Name __attribute__((unused))) -> JITSymbol { -+ return nullptr; -+ }, -+#else - [](const std::string &Name __attribute__((unused))) -> JITSymbol { - return nullptr; - }, -+#endif - [](Error Err) { cantFail(std::move(Err), "lookup failed"); })), - #if LLVM_VERSION_MAJOR > 8 - ObjectLayer(AcknowledgeORCv1Deprecation, --- -2.25.4 - diff --git a/bpftrace-0.11.1.tar.gz b/bpftrace-0.11.1.tar.gz deleted file mode 100644 index c67b1abd25d17e7ca9a5c4603c2b4cfb7647d6c3..0000000000000000000000000000000000000000 Binary files a/bpftrace-0.11.1.tar.gz and /dev/null differ diff --git a/bpftrace-0.11.1-Fix-clear-when-called-on-an-array.patch b/bpftrace-0.11.2-Fix-clear-when-called-on-an-array.patch similarity index 100% rename from bpftrace-0.11.1-Fix-clear-when-called-on-an-array.patch rename to bpftrace-0.11.2-Fix-clear-when-called-on-an-array.patch diff --git a/bpftrace-0.11.1-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch b/bpftrace-0.11.2-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch similarity index 100% rename from bpftrace-0.11.1-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch rename to bpftrace-0.11.2-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch diff --git a/bpftrace-0.11.1-RHEL-8-fixes.patch b/bpftrace-0.11.2-RHEL-8-fixes.patch similarity index 100% rename from bpftrace-0.11.1-RHEL-8-fixes.patch rename to bpftrace-0.11.2-RHEL-8-fixes.patch diff --git a/bpftrace-0.11.2.tar.gz b/bpftrace-0.11.2.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7e0eef7aecae2090c356f433161c502327c5f5d5 Binary files /dev/null and b/bpftrace-0.11.2.tar.gz differ diff --git a/bpftrace.spec b/bpftrace.spec index 05b3772a49d861303b72296f3ed2e529dcdf9aca..2ab54abbd070508357165fbac08dc2d0be1c8410 100644 --- a/bpftrace.spec +++ b/bpftrace.spec @@ -1,20 +1,25 @@ +%define anolis_release .0.1 %bcond_without llvm_static Name: bpftrace -Version: 0.11.1 -Release: 3%{?dist} +Version: 0.11.2 +Release: 1%{anolis_release}%{?dist} Summary: High-level tracing language for Linux eBPF License: ASL 2.0 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}-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch -Patch2: %{name}-%{version}-Fix-clear-when-called-on-an-array.patch +Patch1: %{name}-%{version}-Fix-clear-when-called-on-an-array.patch # WARNING: because of the arch-specific patch, no autosetup is used # Remember to patch accordingly Patch10: %{name}-%{version}-RHEL-8-aarch64-fixes-statsnoop-and-opensnoop.patch +Patch1001: 1001-bpftrace-anolis-fix-build-failed-on-aarch64.patch +Patch1002: 1002-bpftrace-anolis-tests-Add-architecture-specific-testcase-support.patch +Patch1003: 1003-bpftrace-anolis-tests-fix-semantic_analyser.type_ctx-failed-on-aarch64.patch +Patch1004: 1004-bpftrace-anolis-tests-childproc-resume-SIGHUP-to-SIG_DFL-before-test.patch + # Arches will be included as upstream support is added and dependencies are # satisfied in the respective arches ExclusiveArch: x86_64 %{power64} aarch64 s390x @@ -51,12 +56,16 @@ and predecessor tracers such as DTrace and SystemTap %patch0 -p1 %patch1 -p1 -%patch2 -p1 %ifarch aarch64 %patch10 -p1 %endif +%patch1001 -p1 +%patch1002 -p1 +%patch1003 -p1 +%patch1004 -p1 + %build %cmake . \ -DCMAKE_BUILD_TYPE=RelWithDebInfo \ @@ -103,6 +112,15 @@ find %{buildroot}%{_datadir}/%{name}/tools -type f -exec \ %endif %changelog +* Mon Nov 22 2021 Chunmei Xu - 0.11.2-1.0.1 +- fix build failed on aarch64 +- tests: Add architecture specific testcase support +- tests: fix semantic_analyser.type_ctx failed on aarch64 +- tests/childproc: resume SIGHUP to SIG_DFL before test + +* Mon Nov 22 2021 Chunmei Xu - 0.11.2-1 +- update to bpftrace 0.11.2 + * Thu Jan 28 2021 Jerome Marchand - 0.11.1-3 - Add missing libbpf and binutils-dev dependencies