commit 61d3225318c176e512a746ee5393fe3b1de75132 Author: CentOS Sources Date: Mon Nov 9 14:09:23 2020 +0000 import bpftrace-0.11.1-1.el8 diff --git a/.bpftrace.metadata b/.bpftrace.metadata new file mode 100644 index 0000000..86fabde --- /dev/null +++ b/.bpftrace.metadata @@ -0,0 +1 @@ +6bb8d682de04ffd47d565eb2542bc7c7d7b5da84 SOURCES/bpftrace-0.11.1.tar.gz diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7ac4fc0 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/bpftrace-0.11.1.tar.gz diff --git a/SOURCES/bpftrace-0.11.1-Fix-clear-when-called-on-an-array.patch b/SOURCES/bpftrace-0.11.1-Fix-clear-when-called-on-an-array.patch new file mode 100644 index 0000000..491f7c1 --- /dev/null +++ b/SOURCES/bpftrace-0.11.1-Fix-clear-when-called-on-an-array.patch @@ -0,0 +1,49 @@ +From ed9caea4efcffdd9f37c67b272324a87abfd20c8 Mon Sep 17 00:00:00 2001 +From: Jerome Marchand +Date: Thu, 5 Nov 2020 15:17:14 +0100 +Subject: [PATCH] Fix clear() when called on an array + +Fixes the following error: +Error looking up elem: -1 +terminate called after throwing an instance of 'std::runtime_error' + what(): Could not clear map with ident "@", err=-1 +Aborted (core dumped) +--- + src/bpftrace.cpp | 5 +++++ + src/imap.h | 4 ++++ + 2 files changed, 9 insertions(+) + +diff --git a/src/bpftrace.cpp b/src/bpftrace.cpp +index 23b65a5..fe2fb66 100644 +--- a/src/bpftrace.cpp ++++ b/src/bpftrace.cpp +@@ -1147,6 +1147,11 @@ int BPFtrace::print_maps() + int BPFtrace::clear_map(IMap &map) + { + std::vector old_key; ++ if (map.is_array_type()) ++ { ++ return zero_map(map); ++ } ++ + try + { + if (map.type_.IsHistTy() || map.type_.IsLhistTy() || +diff --git a/src/imap.h b/src/imap.h +index 27d0d74..ca9f424 100644 +--- a/src/imap.h ++++ b/src/imap.h +@@ -27,6 +27,10 @@ class IMap + return map_type_ == BPF_MAP_TYPE_PERCPU_HASH || + map_type_ == BPF_MAP_TYPE_PERCPU_ARRAY; + } ++ bool is_array_type() ++ { ++ return map_type_ == BPF_MAP_TYPE_PERCPU_ARRAY; ++ } + + // unique id of this map. Used by (bpf) runtime to reference + // this map +-- +2.25.4 + diff --git a/SOURCES/bpftrace-0.11.1-RHEL-8-fixes.patch b/SOURCES/bpftrace-0.11.1-RHEL-8-fixes.patch new file mode 100644 index 0000000..df3586e --- /dev/null +++ b/SOURCES/bpftrace-0.11.1-RHEL-8-fixes.patch @@ -0,0 +1,56 @@ +From 30cd8a899ec375ca0e46db51fa48ee80c5463470 Mon Sep 17 00:00:00 2001 +From: Jerome Marchand +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 + diff --git a/SOURCES/bpftrace-0.11.1-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch b/SOURCES/bpftrace-0.11.1-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch new file mode 100644 index 0000000..43b02fa --- /dev/null +++ b/SOURCES/bpftrace-0.11.1-irbuilderbpf.cpp-bpforc.h-Fix-compilation-with-LLVM-.patch @@ -0,0 +1,282 @@ +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/SPECS/bpftrace.spec b/SPECS/bpftrace.spec new file mode 100644 index 0000000..1270474 --- /dev/null +++ b/SPECS/bpftrace.spec @@ -0,0 +1,145 @@ +%bcond_without llvm_static + +Name: bpftrace +Version: 0.11.1 +Release: 1%{?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 + +# Arches will be included as upstream support is added and dependencies are +# satisfied in the respective arches +ExclusiveArch: x86_64 %{power64} aarch64 s390x + +BuildRequires: gcc-c++ +BuildRequires: bison +BuildRequires: flex +BuildRequires: cmake +BuildRequires: elfutils-libelf-devel +BuildRequires: zlib-devel +BuildRequires: llvm-devel +BuildRequires: clang-devel +BuildRequires: bcc-devel + +%if %{with llvm_static} +BuildRequires: llvm-static +%endif + +%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 +backend to compile scripts to BPF-bytecode and makes use of BCC for +interacting with the Linux BPF system, as well as existing Linux tracing +capabilities: kernel dynamic tracing (kprobes), user-level dynamic tracing +(uprobes), and tracepoints. The BPFtrace language is inspired by awk and C, +and predecessor tracers such as DTrace and SystemTap + + +%prep +%autosetup -p1 + +%build +%cmake . \ + -DCMAKE_BUILD_TYPE=RelWithDebInfo \ + -DBUILD_TESTING:BOOL=OFF \ + -DBUILD_SHARED_LIBS:BOOL=OFF +%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}/ + + +%files +%doc README.md CONTRIBUTING-TOOLS.md +%doc docs/reference_guide.md docs/tutorial_one_liners.md +%license LICENSE +%dir %{_datadir}/%{name} +%dir %{_datadir}/%{name}/tools +%dir %{_datadir}/%{name}/tools/doc +%{_bindir}/%{name} +%{_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 + +%changelog +* Fri Nov 06 2020 Jerome Marchand - 0.11.1-1 +- Rebase on bpftrace 0.11.1 + +* Tue Oct 27 2020 Jerome Marchand - 0.10.0-5 +- Rebuild for bcc 0.16.0 + +* Thu Jun 11 2020 Jerome Marchand - 0.10.0-4 +- Fix KBUILD_MODNAME + +* Thu Jun 11 2020 Jerome Marchand - 0.10.0-3 +- Fix ENOMEM issue on arm64 machine with many cpus +- Fix statsnoop and opensnoop on aarch64 +- Drop tcpdrop on ppc64 + +* Tue May 05 2020 Jerome Marchand - 0.10.0-2 +- Fix libpthread path in threadsnoop + +* Wed Apr 22 2020 Jerome Marchand - 0.10.0-1 +- Rebase on bpftrace 0.10.0 + +* Fri Nov 08 2019 Jerome Marchand - 0.9.2-1 +- Rebase on bpftrace 0.9.2 + +* Tue Jun 18 2019 Jerome Marchand - 0.9-3 +- Don't allow to raw_spin_lock* kprobes that can deadlock the kernel. + +* Wed Jun 12 2019 Jerome Marchand - 0.9-2 +- Fixes gethostlatency +- Fixes a struct definition issue that made several tools fail +- Add CI gating + +* Wed May 15 2019 Jerome Marchand - 0.9.1 +- Original build on RHEL 8 + +* Thu Apr 25 2019 Augusto Caringi - 0.9-3 +- Rebuilt for bcc 0.9.0 + +* Mon Apr 22 2019 Neal Gompa - 0.9-2 +- Fix Source0 reference +- Use make_build macro for calling make + +* Mon Apr 1 2019 Peter Robinson 0.9-1 +- Build on aarch64 and s390x + +* Mon Mar 25 2019 Augusto Caringi - 0.9-0 +- Updated to version 0.9 + +* Thu Jan 31 2019 Fedora Release Engineering - 0.0-2.20181210gitc49b333 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Mon Dec 10 2018 Augusto Caringi - 0.0-1.20181210gitc49b333 +- Updated to latest upstream (c49b333c034a6d29a7ce90f565e27da1061af971) + +* Wed Nov 07 2018 Augusto Caringi - 0.0-1.20181107git029717b +- Initial import