From dabd328a754230923bbecb718208d5324b851d40 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Tue, 15 Nov 2022 01:38:21 -0500 Subject: [PATCH] import bpftrace-0.13.1-1.el9 --- .bpftrace.metadata | 2 +- .gitignore | 2 +- ...2.1-Fix-single-arg-wildcard-listings.patch | 72 -- ...bpftrace-0.13.1-Fix-LLVM-13-warnings.patch | 834 ++++++++++++++++++ ....13.1-Fix-compile-under-llvm14-trunk.patch | 42 + ...ftrace-0.13.1-Fix-libbtf-0.6.0-build.patch | 39 + ...atch => bpftrace-0.13.1-Fix-mdflush.patch} | 8 +- ...tch => bpftrace-0.13.1-RHEL-9-fixes.patch} | 10 +- ...rch64-fixes-statsnoop-and-opensnoop.patch} | 8 +- ...te-bio-tools-to-work-on-kernel-5.16.patch} | 50 +- ...handle-Linux-5.17-block-layer-update.patch | 98 ++ ...-0.13.1-orc-Fix-build-with-clang-13.patch} | 23 +- ...-rely-on-BTF-instead-of-header-files.patch | 285 ++++++ SPECS/bpftrace.spec | 18 +- 14 files changed, 1361 insertions(+), 130 deletions(-) delete mode 100644 SOURCES/bpftrace-0.12.1-Fix-single-arg-wildcard-listings.patch create mode 100644 SOURCES/bpftrace-0.13.1-Fix-LLVM-13-warnings.patch create mode 100644 SOURCES/bpftrace-0.13.1-Fix-compile-under-llvm14-trunk.patch create mode 100644 SOURCES/bpftrace-0.13.1-Fix-libbtf-0.6.0-build.patch rename SOURCES/{bpftrace-0.12.1-Fix-mdflush.patch => bpftrace-0.13.1-Fix-mdflush.patch} (80%) rename SOURCES/{bpftrace-0.12.1-RHEL-9-fixes.patch => bpftrace-0.13.1-RHEL-9-fixes.patch} (89%) rename SOURCES/{bpftrace-0.12.1-aarch64-fixes-statsnoop-and-opensnoop.patch => bpftrace-0.13.1-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch} (89%) rename SOURCES/{bpftrace-0.12.1-Update-bio-tools-to-work-on-RHEL9.patch => bpftrace-0.13.1-Update-bio-tools-to-work-on-kernel-5.16.patch} (57%) create mode 100644 SOURCES/bpftrace-0.13.1-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch rename SOURCES/{bpftrace-0.12.1-orc-Fix-build-with-clang-13.patch => bpftrace-0.13.1-orc-Fix-build-with-clang-13.patch} (87%) create mode 100644 SOURCES/bpftrace-0.13.1-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch diff --git a/.bpftrace.metadata b/.bpftrace.metadata index c60183b..c374d63 100644 --- a/.bpftrace.metadata +++ b/.bpftrace.metadata @@ -1 +1 @@ -9cc3a1b5d4efd1649753cdb374102440c6625b57 SOURCES/bpftrace-0.12.1.tar.gz +ddc4abda22761b58fc7fc49623e60ca7e3ae26ff SOURCES/bpftrace-0.13.1.tar.gz diff --git a/.gitignore b/.gitignore index 7746f0d..17e0d2d 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1 @@ -SOURCES/bpftrace-0.12.1.tar.gz +SOURCES/bpftrace-0.13.1.tar.gz diff --git a/SOURCES/bpftrace-0.12.1-Fix-single-arg-wildcard-listings.patch b/SOURCES/bpftrace-0.12.1-Fix-single-arg-wildcard-listings.patch deleted file mode 100644 index 1841c93..0000000 --- a/SOURCES/bpftrace-0.12.1-Fix-single-arg-wildcard-listings.patch +++ /dev/null @@ -1,72 +0,0 @@ -From b7fd0900b18c4b640926e0bb830464565a527ca1 Mon Sep 17 00:00:00 2001 -From: Daniel Xu -Date: Mon, 5 Apr 2021 14:35:08 -0700 -Subject: [PATCH] Fix single arg wildcard listings - -The docs say we can do stuff like - - # bpftrace -l "*sleep*" - -so we should probably implement it. We probably regressed on this during -the probe matching refactoring. ---- - src/ast/attachpoint_parser.cpp | 10 +++++++--- - tests/runtime/regression | 6 ++++++ - 2 files changed, 13 insertions(+), 3 deletions(-) - -diff --git a/src/ast/attachpoint_parser.cpp b/src/ast/attachpoint_parser.cpp -index cfac09bc..b62549d7 100644 ---- a/src/ast/attachpoint_parser.cpp -+++ b/src/ast/attachpoint_parser.cpp -@@ -77,6 +77,9 @@ AttachPointParser::State AttachPointParser::parse_attachpoint(AttachPoint &ap) - std::set probe_types; - if (has_wildcard(parts_.front())) - { -+ // Single argument listing looks at all relevant probe types -+ std::string probetype_query = (parts_.size() == 1) ? "*" : parts_.front(); -+ - // Probe type expansion - // If PID is specified or the second part of the attach point is a path - // (contains '/'), use userspace probe types. -@@ -85,12 +88,12 @@ AttachPointParser::State AttachPointParser::parse_attachpoint(AttachPoint &ap) - (parts_.size() >= 2 && parts_[1].find('/') != std::string::npos)) - { - probe_types = bpftrace_.probe_matcher_->expand_probetype_userspace( -- parts_.front()); -+ probetype_query); - } - else - { - probe_types = bpftrace_.probe_matcher_->expand_probetype_kernel( -- parts_.front()); -+ probetype_query); - } - } - else -@@ -111,7 +114,8 @@ AttachPointParser::State AttachPointParser::parse_attachpoint(AttachPoint &ap) - for (const auto &probe_type : probe_types) - { - std::string raw_input = ap.raw_input; -- erase_prefix(raw_input); -+ if (parts_.size() > 1) -+ erase_prefix(raw_input); - raw_input = probe_type + ":" + raw_input; - // New attach points have ignore_invalid set to true - probe types for - // which raw_input has invalid number of parts will be ignored (instead -diff --git a/tests/runtime/regression b/tests/runtime/regression -index 7f40ffdb..b7fa4653 100644 ---- a/tests/runtime/regression -+++ b/tests/runtime/regression -@@ -33,3 +33,9 @@ NAME c_array_indexing - RUN bpftrace -v -e 'struct Foo { int a; uint8_t b[10]; } uprobe:testprogs/uprobe_test:function2 { $foo = (struct Foo *)arg0; printf("%c %c %c %c %c\n", $foo->b[0], $foo->b[1], $foo->b[2], $foo->b[3], $foo->b[4]) }' -c ./testprogs/uprobe_test - EXPECT h e l l o - TIMEOUT 5 -+ -+# https://github.com/iovisor/bpftrace/issues/1773 -+NAME single_arg_wildcard_listing -+RUN bpftrace -l "*do_nanosleep*" -+EXPECT kprobe:do_nanosleep -+TIMEOUT 1 --- -2.34.1 - diff --git a/SOURCES/bpftrace-0.13.1-Fix-LLVM-13-warnings.patch b/SOURCES/bpftrace-0.13.1-Fix-LLVM-13-warnings.patch new file mode 100644 index 0000000..4bccd87 --- /dev/null +++ b/SOURCES/bpftrace-0.13.1-Fix-LLVM-13-warnings.patch @@ -0,0 +1,834 @@ +From 291cb44a513049e94b8de80f58fa7f08d3491aea Mon Sep 17 00:00:00 2001 +From: Viktor Malik +Date: Mon, 10 Jan 2022 16:41:05 +0100 +Subject: [PATCH 8/8] Fix LLVM 13 warnings + +Since LLVM 13, CreateGEP and CreateLoad require explicit types. +--- + src/ast/codegen_llvm.cpp | 265 ++++++++++++++++++++++++--------------- + src/ast/irbuilderbpf.cpp | 56 +++++---- + 2 files changed, 200 insertions(+), 121 deletions(-) + +diff --git a/src/ast/codegen_llvm.cpp b/src/ast/codegen_llvm.cpp +index d30327a2..0bd23276 100644 +--- a/src/ast/codegen_llvm.cpp ++++ b/src/ast/codegen_llvm.cpp +@@ -224,9 +224,10 @@ void CodegenLLVM::visit(Builtin &builtin) + // LLVM optimization is possible to transform `(uint64*)ctx` into + // `(uint8*)ctx`, but sometimes this causes invalid context access. + // Mark every context acess to supporess any LLVM optimization. +- expr_ = b_.CreateLoad(b_.getInt64Ty(), +- b_.CreateGEP(ctx, b_.getInt64(offset)), +- builtin.ident); ++ expr_ = b_.CreateLoad( ++ b_.getInt64Ty(), ++ b_.CreateGEP(b_.getInt64Ty(), ctx, b_.getInt64(offset)), ++ builtin.ident); + // LLVM 7.0 <= does not have CreateLoad(*Ty, *Ptr, isVolatile, Name), + // so call setVolatile() manually + dyn_cast(expr_)->setVolatile(true); +@@ -249,16 +250,17 @@ void CodegenLLVM::visit(Builtin &builtin) + + int arg_num = atoi(builtin.ident.substr(4).c_str()); + Value *ctx = b_.CreatePointerCast(ctx_, b_.getInt64Ty()->getPointerTo()); +- Value *sp = b_.CreateLoad(b_.getInt64Ty(), +- b_.CreateGEP(ctx, b_.getInt64(sp_offset)), +- "reg_sp"); ++ Value *sp = b_.CreateLoad( ++ b_.getInt64Ty(), ++ b_.CreateGEP(b_.getInt64Ty(), ctx, b_.getInt64(sp_offset)), ++ "reg_sp"); + dyn_cast(sp)->setVolatile(true); + AllocaInst *dst = b_.CreateAllocaBPF(builtin.type, builtin.ident); + Value *src = b_.CreateAdd(sp, + b_.getInt64((arg_num + arch::arg_stack_offset()) * + sizeof(uintptr_t))); + b_.CreateProbeRead(ctx_, dst, 8, src, builtin.type.GetAS(), builtin.loc); +- expr_ = b_.CreateLoad(dst); ++ expr_ = b_.CreateLoad(b_.GetType(builtin.type), dst); + b_.CreateLifetimeEnd(dst); + } + else if (builtin.ident == "probe") +@@ -526,8 +528,12 @@ void CodegenLLVM::visit(Call &call) + b_.CREATE_MEMSET(buf, b_.getInt8(0), bpftrace_.strlen_, 1); + auto arg0 = call.vargs->front(); + auto scoped_del = accept(call.vargs->front()); +- b_.CreateProbeReadStr( +- ctx_, buf, b_.CreateLoad(strlen), expr_, arg0->type.GetAS(), call.loc); ++ b_.CreateProbeReadStr(ctx_, ++ buf, ++ b_.CreateLoad(b_.getInt64Ty(), strlen), ++ expr_, ++ arg0->type.GetAS(), ++ call.loc); + b_.CreateLifetimeEnd(strlen); + + expr_ = buf; +@@ -569,12 +575,14 @@ void CodegenLLVM::visit(Call &call) + false); + AllocaInst *buf = b_.CreateAllocaBPF(buf_struct, "buffer"); + +- Value *buf_len_offset = b_.CreateGEP(buf, ++ Value *buf_len_offset = b_.CreateGEP(buf_struct, ++ buf, + { b_.getInt32(0), b_.getInt32(0) }); + length = b_.CreateIntCast(length, buf_struct->getElementType(0), false); + b_.CreateStore(length, buf_len_offset); + +- Value *buf_data_offset = b_.CreateGEP(buf, ++ Value *buf_data_offset = b_.CreateGEP(buf_struct, ++ buf, + { b_.getInt32(0), b_.getInt32(1) }); + b_.CREATE_MEMSET(buf_data_offset, + b_.GetIntSameSize(0, elements.at(0)), +@@ -664,14 +672,14 @@ void CodegenLLVM::visit(Call &call) + b_.SetInsertPoint(notzero); + b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::join)), perfdata); + b_.CreateStore(b_.getInt64(join_id_), +- b_.CreateGEP(perfdata, b_.getInt64(8))); ++ b_.CreateGEP(b_.getInt8Ty(), perfdata, b_.getInt64(8))); + join_id_++; + AllocaInst *arr = b_.CreateAllocaBPF(b_.getInt64Ty(), call.func + "_r0"); + b_.CreateProbeRead(ctx_, arr, 8, expr_, addrspace, call.loc); + b_.CreateProbeReadStr(ctx_, + b_.CreateAdd(perfdata, b_.getInt64(8 + 8)), + bpftrace_.join_argsize_, +- b_.CreateLoad(arr), ++ b_.CreateLoad(b_.getInt64Ty(), arr), + addrspace, + call.loc); + +@@ -679,14 +687,18 @@ void CodegenLLVM::visit(Call &call) + { + // argi + b_.CreateStore(b_.CreateAdd(expr_, b_.getInt64(8 * i)), first); +- b_.CreateProbeRead( +- ctx_, second, 8, b_.CreateLoad(first), addrspace, call.loc); ++ b_.CreateProbeRead(ctx_, ++ second, ++ 8, ++ b_.CreateLoad(b_.getInt64Ty(), first), ++ addrspace, ++ call.loc); + b_.CreateProbeReadStr( + ctx_, + b_.CreateAdd(perfdata, + b_.getInt64(8 + 8 + i * bpftrace_.join_argsize_)), + bpftrace_.join_argsize_, +- b_.CreateLoad(second), ++ b_.CreateLoad(b_.getInt64Ty(), second), + addrspace, + call.loc); + } +@@ -729,7 +741,9 @@ void CodegenLLVM::visit(Call &call) + + AllocaInst *buf = b_.CreateAllocaBPF(inet_struct, "inet"); + +- Value *af_offset = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }); ++ Value *af_offset = b_.CreateGEP(inet_struct, ++ buf, ++ { b_.getInt64(0), b_.getInt32(0) }); + Value *af_type; + + auto inet = call.vargs->at(0); +@@ -752,7 +766,9 @@ void CodegenLLVM::visit(Call &call) + } + b_.CreateStore(af_type, af_offset); + +- Value *inet_offset = b_.CreateGEP(buf, {b_.getInt32(0), b_.getInt32(1)}); ++ Value *inet_offset = b_.CreateGEP(inet_struct, ++ buf, ++ { b_.getInt32(0), b_.getInt32(1) }); + b_.CREATE_MEMSET(inet_offset, b_.getInt8(0), 16, 1); + + auto scoped_del = accept(inet); +@@ -785,9 +801,10 @@ void CodegenLLVM::visit(Call &call) + } + + Value *ctx = b_.CreatePointerCast(ctx_, b_.getInt64Ty()->getPointerTo()); +- expr_ = b_.CreateLoad(b_.getInt64Ty(), +- b_.CreateGEP(ctx, b_.getInt64(offset)), +- call.func + "_" + reg_name); ++ expr_ = b_.CreateLoad( ++ b_.getInt64Ty(), ++ b_.CreateGEP(b_.getInt64Ty(), ctx, b_.getInt64(offset)), ++ call.func + "_" + reg_name); + dyn_cast(expr_)->setVolatile(true); + } + else if (call.func == "printf") +@@ -812,8 +829,10 @@ void CodegenLLVM::visit(Call &call) + auto scoped_del = accept(&arg); + + // and store it to data area +- Value *offset = b_.CreateGEP( +- data, { b_.getInt64(0), b_.getInt64((i - 1) * ptr_size) }); ++ Value *offset = b_.CreateGEP(b_.GetType(data_type), ++ data, ++ { b_.getInt64(0), ++ b_.getInt64((i - 1) * ptr_size) }); + b_.CreateStore(expr_, offset); + + // keep the expression alive, so it's still there +@@ -901,7 +920,9 @@ void CodegenLLVM::visit(Call &call) + AllocaInst *buf = b_.CreateAllocaBPF(event_struct, + call.func + "_" + map.ident); + +- auto aa_ptr = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }); ++ auto aa_ptr = b_.CreateGEP(event_struct, ++ buf, ++ { b_.getInt64(0), b_.getInt32(0) }); + if (call.func == "clear") + b_.CreateStore(b_.GetIntSameSize(asyncactionint(AsyncAction::clear), + elements.at(0)), +@@ -912,7 +933,9 @@ void CodegenLLVM::visit(Call &call) + aa_ptr); + + auto id = bpftrace_.maps[map.ident].value()->id; +- auto *ident_ptr = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }); ++ auto *ident_ptr = b_.CreateGEP(event_struct, ++ buf, ++ { b_.getInt64(0), b_.getInt32(1) }); + b_.CreateStore(b_.GetIntSameSize(id, elements.at(1)), ident_ptr); + + b_.CreatePerfEventOutput(ctx_, buf, getStructSize(event_struct)); +@@ -928,12 +951,13 @@ void CodegenLLVM::visit(Call &call) + + AllocaInst *buf = b_.CreateAllocaBPF(time_struct, call.func + "_t"); + +- b_.CreateStore(b_.GetIntSameSize(asyncactionint(AsyncAction::time), +- elements.at(0)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) })); ++ b_.CreateStore( ++ b_.GetIntSameSize(asyncactionint(AsyncAction::time), elements.at(0)), ++ b_.CreateGEP(time_struct, buf, { b_.getInt64(0), b_.getInt32(0) })); + +- b_.CreateStore(b_.GetIntSameSize(time_id_, elements.at(1)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) })); ++ b_.CreateStore( ++ b_.GetIntSameSize(time_id_, elements.at(1)), ++ b_.CreateGEP(time_struct, buf, { b_.getInt64(0), b_.getInt32(1) })); + + time_id_++; + b_.CreatePerfEventOutput(ctx_, buf, getStructSize(time_struct)); +@@ -948,13 +972,15 @@ void CodegenLLVM::visit(Call &call) + true); + + AllocaInst *buf = b_.CreateAllocaBPF(strftime_struct, call.func + "_args"); +- b_.CreateStore(b_.GetIntSameSize(strftime_id_, elements.at(0)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) })); ++ b_.CreateStore( ++ b_.GetIntSameSize(strftime_id_, elements.at(0)), ++ b_.CreateGEP(strftime_struct, buf, { b_.getInt64(0), b_.getInt32(0) })); + strftime_id_++; + Expression *arg = call.vargs->at(1); + auto scoped_del = accept(arg); +- b_.CreateStore(expr_, +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) })); ++ b_.CreateStore( ++ expr_, ++ b_.CreateGEP(strftime_struct, buf, { b_.getInt64(0), b_.getInt32(1) })); + expr_ = buf; + } + else if (call.func == "kstack" || call.func == "ustack") +@@ -1068,11 +1094,12 @@ void CodegenLLVM::visit(Call &call) + AllocaInst *buf = b_.CreateAllocaBPF(unwatch_struct, "unwatch"); + size_t struct_size = datalayout().getTypeAllocSize(unwatch_struct); + +- b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::watchpoint_detach)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) })); ++ b_.CreateStore( ++ b_.getInt64(asyncactionint(AsyncAction::watchpoint_detach)), ++ b_.CreateGEP(unwatch_struct, buf, { b_.getInt64(0), b_.getInt32(0) })); + b_.CreateStore( + b_.CreateIntCast(expr_, b_.getInt64Ty(), false /* unsigned */), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) })); ++ b_.CreateGEP(unwatch_struct, buf, { b_.getInt64(0), b_.getInt32(1) })); + b_.CreatePerfEventOutput(ctx_, buf, struct_size); + b_.CreateLifetimeEnd(buf); + expr_ = nullptr; +@@ -1102,7 +1129,8 @@ void CodegenLLVM::visit(Variable &var) + } + else + { +- expr_ = b_.CreateLoad(variables_[var.ident]); ++ auto *var_alloca = variables_[var.ident]; ++ expr_ = b_.CreateLoad(var_alloca->getType()->getElementType(), var_alloca); + } + } + +@@ -1379,13 +1407,15 @@ void CodegenLLVM::visit(Unop &unop) + if (unop.is_post_op) + expr_ = oldval; + else +- expr_ = b_.CreateLoad(newval); ++ expr_ = b_.CreateLoad(b_.GetType(map.type), newval); + b_.CreateLifetimeEnd(newval); + } + else if (unop.expr->is_variable) + { + Variable &var = static_cast(*unop.expr); +- Value *oldval = b_.CreateLoad(variables_[var.ident]); ++ Value *oldval = b_.CreateLoad( ++ variables_[var.ident]->getType()->getElementType(), ++ variables_[var.ident]); + Value *newval; + if (is_increment) + newval = b_.CreateAdd(oldval, b_.getInt64(1)); +@@ -1411,9 +1441,10 @@ void CodegenLLVM::visit(Unop &unop) + : type.GetSize(); + auto as = type.GetAS(); + +- AllocaInst *dst = b_.CreateAllocaBPF(SizedType(type.type, size), "deref"); ++ auto dst_type = SizedType(type.type, size); ++ AllocaInst *dst = b_.CreateAllocaBPF(dst_type, "deref"); + b_.CreateProbeRead(ctx_, dst, size, expr_, as, unop.loc); +- expr_ = b_.CreateIntCast(b_.CreateLoad(dst), ++ expr_ = b_.CreateIntCast(b_.CreateLoad(b_.GetType(dst_type), dst), + b_.getInt64Ty(), + type.IsSigned()); + b_.CreateLifetimeEnd(dst); +@@ -1434,7 +1465,7 @@ void CodegenLLVM::visit(Unop &unop) + int size = unop.type.IsIntegerTy() ? et->GetIntBitWidth() / 8 : 8; + AllocaInst *dst = b_.CreateAllocaBPF(*et, "deref"); + b_.CreateProbeRead(ctx_, dst, size, expr_, type.GetAS(), unop.loc); +- expr_ = b_.CreateIntCast(b_.CreateLoad(dst), ++ expr_ = b_.CreateIntCast(b_.CreateLoad(b_.GetType(*et), dst), + b_.getInt64Ty(), + unop.type.IsSigned()); + b_.CreateLifetimeEnd(dst); +@@ -1492,7 +1523,7 @@ void CodegenLLVM::visit(Ternary &ternary) + b_.CreateBr(done); + + b_.SetInsertPoint(done); +- expr_ = b_.CreateLoad(result); ++ expr_ = b_.CreateLoad(b_.GetType(ternary.type), result); + } + else if (ternary.type.IsStringTy()) + { +@@ -1549,7 +1580,8 @@ void CodegenLLVM::visit(FieldAccess &acc) + } + else if (type.IsTupleTy()) + { +- Value *src = b_.CreateGEP(expr_, ++ Value *src = b_.CreateGEP(b_.GetType(type), ++ expr_, + { b_.getInt32(0), b_.getInt32(acc.index) }); + SizedType &elem_type = type.GetFields()[acc.index].type; + +@@ -1596,10 +1628,12 @@ void CodegenLLVM::visit(FieldAccess &acc) + if (field.is_bitfield) + { + Value *raw; ++ auto field_type = b_.GetType(field.type); + if (type.IsCtxAccess()) +- raw = b_.CreateLoad( +- b_.CreateIntToPtr(src, b_.GetType(field.type)->getPointerTo()), +- true); ++ raw = b_.CreateLoad(field_type, ++ b_.CreateIntToPtr(src, ++ field_type->getPointerTo()), ++ true); + else + { + AllocaInst *dst = b_.CreateAllocaBPF(field.type, +@@ -1610,7 +1644,7 @@ void CodegenLLVM::visit(FieldAccess &acc) + b_.CREATE_MEMSET(dst, b_.getInt8(0), field.type.GetSize(), 1); + b_.CreateProbeRead( + ctx_, dst, field.bitfield.read_bytes, src, type.GetAS(), acc.loc); +- raw = b_.CreateLoad(dst); ++ raw = b_.CreateLoad(field_type, dst); + b_.CreateLifetimeEnd(dst); + } + size_t rshiftbits; +@@ -1638,7 +1672,8 @@ void CodegenLLVM::visit(FieldAccess &acc) + // offset which we add to the start of the tracepoint struct. + expr_ = b_.CreateLoad( + b_.getInt32Ty(), +- b_.CreateGEP(b_.CreatePointerCast(ctx_, ++ b_.CreateGEP(b_.getInt32Ty(), ++ b_.CreatePointerCast(ctx_, + b_.getInt32Ty()->getPointerTo()), + b_.getInt64(field.offset / 4))); + expr_ = b_.CreateIntCast(expr_, b_.getInt64Ty(), false); +@@ -1757,7 +1792,9 @@ void CodegenLLVM::visit(Tuple &tuple) + Expression *elem = tuple.elems->at(i); + auto scoped_del = accept(elem); + +- Value *dst = b_.CreateGEP(buf, { b_.getInt32(0), b_.getInt32(i) }); ++ Value *dst = b_.CreateGEP(tuple_ty, ++ buf, ++ { b_.getInt32(0), b_.getInt32(i) }); + + if (onStack(elem->type)) + b_.CREATE_MEMCPY(dst, expr_, elem->type.GetSize(), 1); +@@ -2357,6 +2394,7 @@ std::tuple CodegenLLVM::getMapKey( + size += expr->type.GetSize(); + } + key = b_.CreateAllocaBPF(size, map.ident + "_key"); ++ auto *key_type = ArrayType::get(b_.getInt8Ty(), size); + + int offset = 0; + // Construct a map key in the stack +@@ -2364,7 +2402,8 @@ std::tuple CodegenLLVM::getMapKey( + { + auto scoped_del = accept(expr); + Value *offset_val = b_.CreateGEP( +- key, { b_.getInt64(0), b_.getInt64(offset) }); ++ key_type, key, ++ { b_.getInt64(0), b_.getInt64(offset) }); + + if (onStack(expr->type)) + b_.CREATE_MEMCPY(offset_val, expr_, expr->type.GetSize(), 1); +@@ -2417,18 +2456,19 @@ AllocaInst *CodegenLLVM::getHistMapKey(Map &map, Value *log2) + size += expr->type.GetSize(); + } + key = b_.CreateAllocaBPF(size, map.ident + "_key"); ++ auto *key_type = ArrayType::get(b_.getInt8Ty(), size); + + int offset = 0; + for (Expression *expr : *map.vargs) { + auto scoped_del = accept(expr); +- Value *offset_val = b_.CreateGEP(key, {b_.getInt64(0), b_.getInt64(offset)}); ++ Value *offset_val = b_.CreateGEP(key_type, key, {b_.getInt64(0), b_.getInt64(offset)}); + if (shouldBeOnStackAlready(expr->type)) + b_.CREATE_MEMCPY(offset_val, expr_, expr->type.GetSize(), 1); + else + b_.CreateStore(expr_, offset_val); + offset += expr->type.GetSize(); + } +- Value *offset_val = b_.CreateGEP(key, {b_.getInt64(0), b_.getInt64(offset)}); ++ Value *offset_val = b_.CreateGEP(key_type, key, {b_.getInt64(0), b_.getInt64(offset)}); + b_.CreateStore(log2, offset_val); + } + else +@@ -2475,7 +2515,7 @@ Value *CodegenLLVM::createLogicalAnd(Binop &binop) + b_.CreateBr(merge_block); + + b_.SetInsertPoint(merge_block); +- return b_.CreateLoad(result); ++ return b_.CreateLoad(b_.getInt64Ty(), result); + } + + Value *CodegenLLVM::createLogicalOr(Binop &binop) +@@ -2514,7 +2554,7 @@ Value *CodegenLLVM::createLogicalOr(Binop &binop) + b_.CreateBr(merge_block); + + b_.SetInsertPoint(merge_block); +- return b_.CreateLoad(result); ++ return b_.CreateLoad(b_.getInt64Ty(), result); + } + + Function *CodegenLLVM::createLog2Function() +@@ -2558,34 +2598,37 @@ Function *CodegenLLVM::createLog2Function() + // test for less than zero + BasicBlock *is_less_than_zero = BasicBlock::Create(module_->getContext(), "hist.is_less_than_zero", log2_func); + BasicBlock *is_not_less_than_zero = BasicBlock::Create(module_->getContext(), "hist.is_not_less_than_zero", log2_func); +- b_.CreateCondBr(b_.CreateICmpSLT(b_.CreateLoad(n_alloc), b_.getInt64(0)), ++ b_.CreateCondBr(b_.CreateICmpSLT(b_.CreateLoad(b_.getInt64Ty(), n_alloc), ++ b_.getInt64(0)), + is_less_than_zero, + is_not_less_than_zero); + b_.SetInsertPoint(is_less_than_zero); +- createRet(b_.CreateLoad(result)); ++ createRet(b_.CreateLoad(b_.getInt64Ty(), result)); + b_.SetInsertPoint(is_not_less_than_zero); + + // test for equal to zero + BasicBlock *is_zero = BasicBlock::Create(module_->getContext(), "hist.is_zero", log2_func); + BasicBlock *is_not_zero = BasicBlock::Create(module_->getContext(), "hist.is_not_zero", log2_func); +- b_.CreateCondBr(b_.CreateICmpEQ(b_.CreateLoad(n_alloc), b_.getInt64(0)), ++ b_.CreateCondBr(b_.CreateICmpEQ(b_.CreateLoad(b_.getInt64Ty(), n_alloc), ++ b_.getInt64(0)), + is_zero, + is_not_zero); + b_.SetInsertPoint(is_zero); + b_.CreateStore(b_.getInt64(1), result); +- createRet(b_.CreateLoad(result)); ++ createRet(b_.CreateLoad(b_.getInt64Ty(), result)); + b_.SetInsertPoint(is_not_zero); + + // power-of-2 index, offset by +2 + b_.CreateStore(b_.getInt64(2), result); + for (int i = 4; i >= 0; i--) + { +- Value *n = b_.CreateLoad(n_alloc); ++ Value *n = b_.CreateLoad(b_.getInt64Ty(), n_alloc); + Value *shift = b_.CreateShl(b_.CreateIntCast(b_.CreateICmpSGE(b_.CreateIntCast(n, b_.getInt64Ty(), false), b_.getInt64(1 << (1<getFunction("log2"); + } +@@ -2635,8 +2678,8 @@ Function *CodegenLLVM::createLinearFunction() + + // algorithm + { +- Value *min = b_.CreateLoad(min_alloc); +- Value *val = b_.CreateLoad(value_alloc); ++ Value *min = b_.CreateLoad(b_.getInt64Ty(), min_alloc); ++ Value *val = b_.CreateLoad(b_.getInt64Ty(), value_alloc); + cmp = b_.CreateICmpSLT(val, min); + } + BasicBlock *lt_min = BasicBlock::Create(module_->getContext(), "lhist.lt_min", linear_func); +@@ -2648,8 +2691,8 @@ Function *CodegenLLVM::createLinearFunction() + + b_.SetInsertPoint(ge_min); + { +- Value *max = b_.CreateLoad(max_alloc); +- Value *val = b_.CreateLoad(value_alloc); ++ Value *max = b_.CreateLoad(b_.getInt64Ty(), max_alloc); ++ Value *val = b_.CreateLoad(b_.getInt64Ty(), value_alloc); + cmp = b_.CreateICmpSGT(val, max); + } + BasicBlock *le_max = BasicBlock::Create(module_->getContext(), "lhist.le_max", linear_func); +@@ -2658,22 +2701,22 @@ Function *CodegenLLVM::createLinearFunction() + + b_.SetInsertPoint(gt_max); + { +- Value *step = b_.CreateLoad(step_alloc); +- Value *min = b_.CreateLoad(min_alloc); +- Value *max = b_.CreateLoad(max_alloc); ++ Value *step = b_.CreateLoad(b_.getInt64Ty(), step_alloc); ++ Value *min = b_.CreateLoad(b_.getInt64Ty(), min_alloc); ++ Value *max = b_.CreateLoad(b_.getInt64Ty(), max_alloc); + Value *div = b_.CreateUDiv(b_.CreateSub(max, min), step); + b_.CreateStore(b_.CreateAdd(div, b_.getInt64(1)), result_alloc); +- createRet(b_.CreateLoad(result_alloc)); ++ createRet(b_.CreateLoad(b_.getInt64Ty(), result_alloc)); + } + + b_.SetInsertPoint(le_max); + { +- Value *step = b_.CreateLoad(step_alloc); +- Value *min = b_.CreateLoad(min_alloc); +- Value *val = b_.CreateLoad(value_alloc); ++ Value *step = b_.CreateLoad(b_.getInt64Ty(), step_alloc); ++ Value *min = b_.CreateLoad(b_.getInt64Ty(), min_alloc); ++ Value *val = b_.CreateLoad(b_.getInt64Ty(), value_alloc); + Value *div3 = b_.CreateUDiv(b_.CreateSub(val, min), step); + b_.CreateStore(b_.CreateAdd(div3, b_.getInt64(1)), result_alloc); +- createRet(b_.CreateLoad(result_alloc)); ++ createRet(b_.CreateLoad(b_.getInt64Ty(), result_alloc)); + } + + b_.restoreIP(ip); +@@ -2711,14 +2754,18 @@ void CodegenLLVM::createFormatStringCall(Call &call, int &id, CallArgs &call_arg + // as the struct is not packed we need to memset it. + b_.CREATE_MEMSET(fmt_args, b_.getInt8(0), struct_size, 1); + +- Value *id_offset = b_.CreateGEP(fmt_args, {b_.getInt32(0), b_.getInt32(0)}); ++ Value *id_offset = b_.CreateGEP(fmt_struct, ++ fmt_args, ++ { b_.getInt32(0), b_.getInt32(0) }); + b_.CreateStore(b_.getInt64(id + asyncactionint(async_action)), id_offset); + + for (size_t i=1; isize(); i++) + { + Expression &arg = *call.vargs->at(i); + auto scoped_del = accept(&arg); +- Value *offset = b_.CreateGEP(fmt_args, {b_.getInt32(0), b_.getInt32(i)}); ++ Value *offset = b_.CreateGEP(fmt_struct, ++ fmt_args, ++ { b_.getInt32(0), b_.getInt32(i) }); + if (needMemcpy(arg.type)) + b_.CREATE_MEMCPY(offset, expr_, arg.type.GetSize(), 1); + else if (arg.type.IsIntegerTy() && arg.type.GetSize() < 8) +@@ -2758,10 +2805,12 @@ void CodegenLLVM::generateWatchpointSetupProbe( + // Pull out function argument + Value *ctx = func->arg_begin(); + int offset = arch::arg_offset(arg_num); +- Value *addr = b_.CreateLoad( +- b_.getInt64Ty(), +- b_.CreateGEP(ctx, b_.getInt64(offset * sizeof(uintptr_t))), +- "arg" + std::to_string(arg_num)); ++ Value *arg = b_.CreateGEP(b_.getInt8Ty(), ++ ctx, ++ b_.getInt64(offset * sizeof(uintptr_t))); ++ Value *addr = b_.CreateLoad(b_.getInt64Ty(), ++ arg, ++ "arg" + std::to_string(arg_num)); + + // Tell userspace to setup the real watchpoint + auto elements = AsyncEvent::Watchpoint().asLLVMType(b_); +@@ -2772,12 +2821,16 @@ void CodegenLLVM::generateWatchpointSetupProbe( + size_t struct_size = datalayout().getTypeAllocSize(watchpoint_struct); + + // Fill in perf event struct +- b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::watchpoint_attach)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) })); +- b_.CreateStore(b_.getInt64(watchpoint_id_), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) })); ++ b_.CreateStore( ++ b_.getInt64(asyncactionint(AsyncAction::watchpoint_attach)), ++ b_.CreateGEP(watchpoint_struct, buf, { b_.getInt64(0), b_.getInt32(0) })); ++ b_.CreateStore( ++ b_.getInt64(watchpoint_id_), ++ b_.CreateGEP(watchpoint_struct, buf, { b_.getInt64(0), b_.getInt32(1) })); + watchpoint_id_++; +- b_.CreateStore(addr, b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(2) })); ++ b_.CreateStore( ++ addr, ++ b_.CreateGEP(watchpoint_struct, buf, { b_.getInt64(0), b_.getInt32(2) })); + b_.CreatePerfEventOutput(ctx, buf, struct_size); + b_.CreateLifetimeEnd(buf); + +@@ -2796,11 +2849,14 @@ void CodegenLLVM::createPrintMapCall(Call &call) + call.func + "_" + map.ident); + + // store asyncactionid: +- b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::print)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) })); ++ b_.CreateStore( ++ b_.getInt64(asyncactionint(AsyncAction::print)), ++ b_.CreateGEP(print_struct, buf, { b_.getInt64(0), b_.getInt32(0) })); + + auto id = bpftrace_.maps[map.ident].value()->id; +- auto *ident_ptr = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }); ++ auto *ident_ptr = b_.CreateGEP(print_struct, ++ buf, ++ { b_.getInt64(0), b_.getInt32(1) }); + b_.CreateStore(b_.GetIntSameSize(id, elements.at(1)), ident_ptr); + + // top, div +@@ -2812,14 +2868,16 @@ void CodegenLLVM::createPrintMapCall(Call &call) + auto scoped_del = accept(call.vargs->at(arg_idx)); + + b_.CreateStore(b_.CreateIntCast(expr_, elements.at(arg_idx), false), +- b_.CreateGEP(buf, ++ b_.CreateGEP(print_struct, ++ buf, + { b_.getInt64(0), b_.getInt32(arg_idx + 1) })); + } + + for (; arg_idx < 3; arg_idx++) + { + b_.CreateStore(b_.GetIntSameSize(0, elements.at(arg_idx)), +- b_.CreateGEP(buf, ++ b_.CreateGEP(print_struct, ++ buf, + { b_.getInt64(0), b_.getInt32(arg_idx + 1) })); + } + +@@ -2844,15 +2902,19 @@ void CodegenLLVM::createPrintNonMapCall(Call &call, int &id) + size_t struct_size = datalayout().getTypeAllocSize(print_struct); + + // Store asyncactionid: +- b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::print_non_map)), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) })); ++ b_.CreateStore( ++ b_.getInt64(asyncactionint(AsyncAction::print_non_map)), ++ b_.CreateGEP(print_struct, buf, { b_.getInt64(0), b_.getInt32(0) })); + + // Store print id +- b_.CreateStore(b_.getInt64(id), +- b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) })); ++ b_.CreateStore( ++ b_.getInt64(id), ++ b_.CreateGEP(print_struct, buf, { b_.getInt64(0), b_.getInt32(1) })); + + // Store content +- Value *content_offset = b_.CreateGEP(buf, { b_.getInt32(0), b_.getInt32(2) }); ++ Value *content_offset = b_.CreateGEP(print_struct, ++ buf, ++ { b_.getInt32(0), b_.getInt32(2) }); + b_.CREATE_MEMSET(content_offset, b_.getInt8(0), arg.type.GetSize(), 1); + if (needMemcpy(arg.type)) + { +@@ -3023,7 +3085,9 @@ void CodegenLLVM::readDatastructElemFromStack(Value *src_data, + src_data = b_.CreateIntToPtr(src_data, + b_.GetType(data_type)->getPointerTo()); + +- Value *src = b_.CreateGEP(src_data, { b_.getInt32(0), index }); ++ Value *src = b_.CreateGEP(b_.GetType(data_type), ++ src_data, ++ { b_.getInt32(0), index }); + + // It may happen that the result pointer type is not correct, in such case + // do a typecast +@@ -3034,7 +3098,7 @@ void CodegenLLVM::readDatastructElemFromStack(Value *src_data, + if (elem_type.IsIntegerTy() || elem_type.IsPtrTy()) + { + // Load the correct type from src +- expr_ = b_.CreateLoad(src, true); ++ expr_ = b_.CreateLoad(b_.GetType(elem_type), src, true); + } + else + { +@@ -3101,7 +3165,8 @@ void CodegenLLVM::probereadDatastructElem(Value *src_data, + // Read data onto stack + if (data_type.IsCtxAccess()) + { +- expr_ = b_.CreateLoad(b_.CreateIntToPtr(src, dst_type->getPointerTo()), ++ expr_ = b_.CreateLoad(dst_type, ++ b_.CreateIntToPtr(src, dst_type->getPointerTo()), + true); + expr_ = b_.CreateIntCast(expr_, b_.getInt64Ty(), elem_type.IsSigned()); + +@@ -3132,7 +3197,7 @@ void CodegenLLVM::probereadDatastructElem(Value *src_data, + AllocaInst *dst = b_.CreateAllocaBPF(elem_type, temp_name); + b_.CreateProbeRead( + ctx_, dst, elem_type.GetSize(), src, data_type.GetAS(), loc); +- expr_ = b_.CreateIntCast(b_.CreateLoad(dst), ++ expr_ = b_.CreateIntCast(b_.CreateLoad(b_.GetType(elem_type), dst), + b_.getInt64Ty(), + elem_type.IsSigned()); + b_.CreateLifetimeEnd(dst); +diff --git a/src/ast/irbuilderbpf.cpp b/src/ast/irbuilderbpf.cpp +index ab1464d3..59771e91 100644 +--- a/src/ast/irbuilderbpf.cpp ++++ b/src/ast/irbuilderbpf.cpp +@@ -94,8 +94,8 @@ AllocaInst *IRBuilderBPF::CreateUSym(llvm::Value *val) + Value *pid = CreateLShr(CreateGetPidTgid(), 32); + + // The extra 0 here ensures the type of addr_offset will be int64 +- Value *addr_offset = CreateGEP(buf, { getInt64(0), getInt32(0) }); +- Value *pid_offset = CreateGEP(buf, { getInt64(0), getInt32(1) }); ++ Value *addr_offset = CreateGEP(usym_t, buf, { getInt64(0), getInt32(0) }); ++ Value *pid_offset = CreateGEP(usym_t, buf, { getInt64(0), getInt32(1) }); + + CreateStore(val, addr_offset); + CreateStore(pid, pid_offset); +@@ -401,7 +401,8 @@ Value *IRBuilderBPF::CreateMapLookupElem(Value *ctx, + if (needMemcpy(type)) + return value; + +- Value *ret = CreateLoad(value); ++ // value is a pointer to i64 ++ Value *ret = CreateLoad(getInt64Ty(), value); + CreateLifetimeEnd(value); + return ret; + } +@@ -621,7 +622,10 @@ Value *IRBuilderBPF::CreateUSDTReadArgument(Value *ctx, + // bpftrace's args are internally represented as 64 bit integers. However, + // the underlying argument (of the target program) may be less than 64 + // bits. So we must be careful to zero out unused bits. +- Value* reg = CreateGEP(ctx, getInt64(offset * sizeof(uintptr_t)), "load_register"); ++ Value *reg = CreateGEP(getInt8Ty(), ++ ctx, ++ getInt64(offset * sizeof(uintptr_t)), ++ "load_register"); + AllocaInst *dst = CreateAllocaBPF(builtin.type, builtin.ident); + Value *index_offset = nullptr; + if (argument->valid & BCC_USDT_ARGUMENT_INDEX_REGISTER_NAME) +@@ -632,7 +636,8 @@ Value *IRBuilderBPF::CreateUSDTReadArgument(Value *ctx, + LOG(FATAL) << "offset for register " << argument->index_register_name + << " not known"; + } +- index_offset = CreateGEP(ctx, ++ index_offset = CreateGEP(getInt8Ty(), ++ ctx, + getInt64(ioffset * sizeof(uintptr_t)), + "load_register"); + index_offset = CreateLoad(getInt64Ty(), index_offset); +@@ -754,7 +759,7 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx __attribute__((unused)), + "strcmp.loop", + parent); + +- auto *ptr = CreateGEP(val, { getInt32(0), getInt32(i) }); ++ auto *ptr = CreateGEP(valp->getElementType(), val, { getInt32(0), getInt32(i) }); + Value *l = CreateLoad(getInt8Ty(), ptr); + Value *r = getInt8(c_str[i]); + Value *cmp = CreateICmpNE(l, r, "strcmp.cmp"); +@@ -767,7 +772,8 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx __attribute__((unused)), + CreateBr(str_ne); + + SetInsertPoint(str_ne); +- Value *result = CreateLoad(store); ++ // store is a pointer to bool (i1 *) ++ Value *result = CreateLoad(getInt1Ty(), store); + CreateLifetimeEnd(store); + result = CreateIntCast(result, getInt64Ty(), false); + return result; +@@ -817,9 +823,11 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx, + } + */ + ++ auto *val1p = dyn_cast(val1->getType()); ++ auto *val2p = dyn_cast(val2->getType()); + #ifndef NDEBUG +- PointerType *val1p = cast(val1->getType()); +- PointerType *val2p = cast(val2->getType()); ++ assert(val1p); ++ assert(val2p); + + assert(val1p->getElementType()->isArrayTy() && + val1p->getElementType()->getArrayElementType() == getInt8Ty()); +@@ -852,11 +860,11 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx, + "strcmp.loop_null_cmp", + parent); + +- auto *ptr1 = CreateGEP(val1, { getInt32(0), getInt32(i) }); ++ auto *ptr1 = CreateGEP(val1p->getElementType(), val1, { getInt32(0), getInt32(i) }); + CreateProbeRead(ctx, val_l, 1, ptr1, as1, loc); + Value *l = CreateLoad(getInt8Ty(), val_l); + +- auto *ptr2 = CreateGEP(val2, { getInt32(0), getInt32(i) }); ++ auto *ptr2 = CreateGEP(val2p->getElementType(), val2, { getInt32(0), getInt32(i) }); + CreateProbeRead(ctx, val_r, 1, ptr2, as2, loc); + Value *r = CreateLoad(getInt8Ty(), val_r); + +@@ -878,7 +886,8 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx, + CreateBr(str_ne); + SetInsertPoint(str_ne); + +- Value *result = CreateLoad(store); ++ // store is a pointer to bool (i1 *) ++ Value *result = CreateLoad(getInt1Ty(), store); + CreateLifetimeEnd(store); + CreateLifetimeEnd(val_l); + CreateLifetimeEnd(val_r); +@@ -1107,7 +1116,7 @@ Value *IRBuilderBPF::CreatKFuncArg(Value *ctx, + { + ctx = CreatePointerCast(ctx, getInt64Ty()->getPointerTo()); + Value *expr = CreateLoad(getInt64Ty(), +- CreateGEP(ctx, getInt64(type.kfarg_idx)), ++ CreateGEP(getInt64Ty(), ctx, getInt64(type.kfarg_idx)), + name); + + // LLVM 7.0 <= does not have CreateLoad(*Ty, *Ptr, isVolatile, Name), +@@ -1161,12 +1170,15 @@ void IRBuilderBPF::CreateHelperError(Value *ctx, + elements, + true); + AllocaInst *buf = CreateAllocaBPF(helper_error_struct, "helper_error_t"); +- CreateStore(GetIntSameSize(asyncactionint(AsyncAction::helper_error), +- elements.at(0)), +- CreateGEP(buf, { getInt64(0), getInt32(0) })); +- CreateStore(GetIntSameSize(error_id, elements.at(1)), +- CreateGEP(buf, { getInt64(0), getInt32(1) })); +- CreateStore(return_value, CreateGEP(buf, { getInt64(0), getInt32(2) })); ++ CreateStore( ++ GetIntSameSize(asyncactionint(AsyncAction::helper_error), elements.at(0)), ++ CreateGEP(helper_error_struct, buf, { getInt64(0), getInt32(0) })); ++ CreateStore( ++ GetIntSameSize(error_id, elements.at(1)), ++ CreateGEP(helper_error_struct, buf, { getInt64(0), getInt32(1) })); ++ CreateStore( ++ return_value, ++ CreateGEP(helper_error_struct, buf, { getInt64(0), getInt32(2) })); + + auto &layout = module_.getDataLayout(); + auto struct_size = layout.getTypeAllocSize(helper_error_struct); +@@ -1256,11 +1268,13 @@ void IRBuilderBPF::CreateSeqPrintf(Value *ctx, + + ctx = CreatePointerCast(ctx, getInt8Ty()->getPointerTo()); + Value *meta = CreateLoad(getInt64Ty()->getPointerTo(), +- CreateGEP(ctx, getInt64(0)), ++ CreateGEP(getInt8Ty(), ctx, getInt64(0)), + "meta"); + dyn_cast(meta)->setVolatile(true); + +- Value *seq = CreateLoad(getInt64Ty(), CreateGEP(meta, getInt64(0)), "seq"); ++ Value *seq = CreateLoad(getInt64Ty(), ++ CreateGEP(getInt64Ty(), meta, getInt64(0)), ++ "seq"); + + CallInst *call = createCall(seq_printf_func, + { seq, fmt, fmt_size, data, data_len }, +-- +2.35.3 + diff --git a/SOURCES/bpftrace-0.13.1-Fix-compile-under-llvm14-trunk.patch b/SOURCES/bpftrace-0.13.1-Fix-compile-under-llvm14-trunk.patch new file mode 100644 index 0000000..1e29854 --- /dev/null +++ b/SOURCES/bpftrace-0.13.1-Fix-compile-under-llvm14-trunk.patch @@ -0,0 +1,42 @@ +From aee721b9b5ed72c287b302df20ea0fffc3cd72bd Mon Sep 17 00:00:00 2001 +From: Yucong Sun +Date: Thu, 21 Oct 2021 14:43:38 -0700 +Subject: [PATCH 7/7] Fix compile under llvm14 (trunk) + +--- + CMakeLists.txt | 2 +- + src/bpforc.h | 4 ++++ + 2 files changed, 5 insertions(+), 1 deletion(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 3beeb027..3cfae6cb 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -159,7 +159,7 @@ else() + find_package(LLVM REQUIRED) + endif() + +- if((${LLVM_VERSION_MAJOR} VERSION_LESS 6) OR (${LLVM_VERSION_MAJOR} VERSION_GREATER 12)) ++ if((${LLVM_VERSION_MAJOR} VERSION_LESS 6) OR (${LLVM_VERSION_MAJOR} VERSION_GREATER 14)) + message(SEND_ERROR "Unsupported LLVM version found: ${LLVM_INCLUDE_DIRS}") + message(SEND_ERROR "Specify an LLVM major version using LLVM_REQUESTED_VERSION=") + endif() +diff --git a/src/bpforc.h b/src/bpforc.h +index cc6a1c97..a0e5c9b8 100644 +--- a/src/bpforc.h ++++ b/src/bpforc.h +@@ -14,7 +14,11 @@ + #include + #include + #include ++#if LLVM_VERSION_MAJOR < 14 + #include ++#else ++#include ++#endif + #include + + #ifdef LLVM_ORC_V2 +-- +2.35.3 + diff --git a/SOURCES/bpftrace-0.13.1-Fix-libbtf-0.6.0-build.patch b/SOURCES/bpftrace-0.13.1-Fix-libbtf-0.6.0-build.patch new file mode 100644 index 0000000..a6ca67b --- /dev/null +++ b/SOURCES/bpftrace-0.13.1-Fix-libbtf-0.6.0-build.patch @@ -0,0 +1,39 @@ +From d26accaba6f911cf82be7e9791bf6440213c5627 Mon Sep 17 00:00:00 2001 +From: Jerome Marchand +Date: Wed, 23 Mar 2022 09:47:25 +0100 +Subject: [PATCH 4/6] Fix libbtf 0.6.0 build + +Libbtf 0.6.0 introduced a new version of btf_dump__new(). The new +version is btf_dump__new_v0_6_0() while the old version was renamed +btf_dump__new_deprecated(). btf_dump__new() is now overloaded, +unfortunately the macro doesn't work on cpp, at least with LLVM 12. +Let's call btf_dump__new_deprecated() explicitely when it's defined. + +Signed-off-by: Jerome Marchand +--- + src/btf.cpp | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/src/btf.cpp b/src/btf.cpp +index a5a5e2c0..fccf0a00 100644 +--- a/src/btf.cpp ++++ b/src/btf.cpp +@@ -24,6 +24,15 @@ + #pragma GCC diagnostic pop + #include + ++/* ++ * Since libbtf 0.6, btf_dump__new() has been overloaded and now can design ++ * either btf_dump__new_v0_6_0() or btf_dump__new_deprecated(), which is the ++ * same as btf_dump__new() for libbtf < 0.6, and the one we still use. ++ */ ++#if LIBBPF_MAJOR_VERSION == 0 && LIBBPF_MINOR_VERSION >= 6 ++#define btf_dump__new(a1, a2, a3, a4) btf_dump__new_deprecated(a1, a2, a3, a4) ++#endif ++ + #include "bpftrace.h" + + namespace bpftrace { +-- +2.35.3 + diff --git a/SOURCES/bpftrace-0.12.1-Fix-mdflush.patch b/SOURCES/bpftrace-0.13.1-Fix-mdflush.patch similarity index 80% rename from SOURCES/bpftrace-0.12.1-Fix-mdflush.patch rename to SOURCES/bpftrace-0.13.1-Fix-mdflush.patch index c2baaa4..20aec4f 100644 --- a/SOURCES/bpftrace-0.12.1-Fix-mdflush.patch +++ b/SOURCES/bpftrace-0.13.1-Fix-mdflush.patch @@ -1,11 +1,13 @@ -From 7453a97005fda29f0b7be8f257736a19d7c13dbe Mon Sep 17 00:00:00 2001 +From 0585b27f6070c0d4016ae9b0d6e1a28261f2e2d2 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Fri, 15 Oct 2021 14:26:28 +0200 -Subject: [PATCH] Fix mdflush +Subject: [PATCH 2/6] Fix mdflush Since kernel commit 309dca309fc ("block: store a block_device pointer in struct bio") struct bio points again to a block_device and not to a gendisk directly. + +Signed-off-by: Jerome Marchand --- tools/mdflush.bt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) @@ -22,5 +24,5 @@ index e767b81d..541abba1 100755 + ((struct bio *)arg1)->bi_bdev->bd_disk->disk_name); } -- -2.31.1 +2.35.3 diff --git a/SOURCES/bpftrace-0.12.1-RHEL-9-fixes.patch b/SOURCES/bpftrace-0.13.1-RHEL-9-fixes.patch similarity index 89% rename from SOURCES/bpftrace-0.12.1-RHEL-9-fixes.patch rename to SOURCES/bpftrace-0.13.1-RHEL-9-fixes.patch index 970f7ae..3863b6c 100644 --- a/SOURCES/bpftrace-0.12.1-RHEL-9-fixes.patch +++ b/SOURCES/bpftrace-0.13.1-RHEL-9-fixes.patch @@ -1,10 +1,12 @@ -From 453e1ea9b9d036cc9cfa0ef2e20c53e926e1b3b8 Mon Sep 17 00:00:00 2001 +From 4d7c2c148f7fb788d74e6cd3b6d65c07a815b0c1 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Tue, 11 Jun 2019 16:41:59 +0200 -Subject: [PATCH] RHEL 9 fixes +Subject: [PATCH 1/6] RHEL 9 fixes Fixes the following RHEL 8 specific issues: - library path in gethostlatency and threadsnoop + +Signed-off-by: Jerome Marchand --- tools/gethostlatency.bt | 12 ++++++------ tools/threadsnoop.bt | 2 +- @@ -39,7 +41,7 @@ index 9f4ec31e..dd389c6f 100755 { $latms = (nsecs - @start[tid]) / 1e6; diff --git a/tools/threadsnoop.bt b/tools/threadsnoop.bt -index 3824bc6d..bdc6e4df 100755 +index 3824bc6d..ab52bc48 100755 --- a/tools/threadsnoop.bt +++ b/tools/threadsnoop.bt @@ -18,7 +18,7 @@ BEGIN @@ -52,5 +54,5 @@ index 3824bc6d..bdc6e4df 100755 printf("%-10u %-6d %-16s %s\n", elapsed / 1e6, pid, comm, usym(arg2)); -- -2.31.1 +2.35.3 diff --git a/SOURCES/bpftrace-0.12.1-aarch64-fixes-statsnoop-and-opensnoop.patch b/SOURCES/bpftrace-0.13.1-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch similarity index 89% rename from SOURCES/bpftrace-0.12.1-aarch64-fixes-statsnoop-and-opensnoop.patch rename to SOURCES/bpftrace-0.13.1-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch index 54ed64a..d5f8e7f 100644 --- a/SOURCES/bpftrace-0.12.1-aarch64-fixes-statsnoop-and-opensnoop.patch +++ b/SOURCES/bpftrace-0.13.1-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch @@ -1,7 +1,7 @@ -From 69f6d7ff04f43451eea2fb028a84a76331bbf6ea Mon Sep 17 00:00:00 2001 +From b23980e4f6ed33d98f4f09ef25ae17baca215cce Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Thu, 11 Jun 2020 14:56:36 +0200 -Subject: [PATCH] RHEL-8: aarch64: fixes statsnoop and opensnoop +Subject: [PATCH 6/6] RHEL: aarch64: fixes statsnoop and opensnoop On aarch64 the open syscall has been dropped. Only openat remains, wich is called by libc open() function. @@ -12,6 +12,8 @@ instance, new(l)stat are missing from aarch64. The only way I can think of fixing thess is RHEL-8 only arch specific patches. + +Signed-off-by: Jerome Marchand --- tools/opensnoop.bt | 2 -- tools/statsnoop.bt | 8 ++------ @@ -60,5 +62,5 @@ index b2d529e2..f612ea94 100755 { $ret = args->ret; -- -2.30.2 +2.35.3 diff --git a/SOURCES/bpftrace-0.12.1-Update-bio-tools-to-work-on-RHEL9.patch b/SOURCES/bpftrace-0.13.1-Update-bio-tools-to-work-on-kernel-5.16.patch similarity index 57% rename from SOURCES/bpftrace-0.12.1-Update-bio-tools-to-work-on-RHEL9.patch rename to SOURCES/bpftrace-0.13.1-Update-bio-tools-to-work-on-kernel-5.16.patch index d89a1f2..edb49c5 100644 --- a/SOURCES/bpftrace-0.12.1-Update-bio-tools-to-work-on-RHEL9.patch +++ b/SOURCES/bpftrace-0.13.1-Update-bio-tools-to-work-on-kernel-5.16.patch @@ -1,84 +1,78 @@ -From 617bb8501c091be2501b3abe4dad47804d5a4278 Mon Sep 17 00:00:00 2001 +From ff22437ef4310a2ab37d732bdd1496a926315691 Mon Sep 17 00:00:00 2001 From: Viktor Malik Date: Mon, 17 Jan 2022 11:15:26 +0100 -Subject: [PATCH] Update bio* tools to work on RHEL9 +Subject: [PATCH 5/6] Update bio* tools to work on kernel 5.16+ -Kernel commit: - 9e6c144e5fee block: inline hot paths of blk_account_io_*() -renamed some functions used in the tools. +Kernel 5.16 contains commit: -Kernel commit: - 5f8d3bf600d2 block: move struct request to blk-mq.h -moved "struct request" to a different header. + https://github.com/torvalds/linux/commit/be6bfe36db1795babe9d92178a47b2e02193cb0f -This fixes both issues. +which renamed some of the functions that the bio* tools attach to. --- - tools/biolatency.bt | 4 ++-- - tools/biosnoop.bt | 6 +++--- - tools/biostacks.bt | 2 +- - 3 files changed, 6 insertions(+), 6 deletions(-) + tools/biolatency.bt | 6 ++++-- + tools/biosnoop.bt | 6 ++++-- + tools/biostacks.bt | 3 ++- + 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/tools/biolatency.bt b/tools/biolatency.bt -index 4ea910b4..8fb0490d 100755 +index 4ea910b4..d5af1f29 100755 --- a/tools/biolatency.bt +++ b/tools/biolatency.bt -@@ -16,12 +16,12 @@ BEGIN +@@ -16,12 +16,14 @@ 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/biosnoop.bt b/tools/biosnoop.bt -index 38ffeb52..6519054c 100755 +index 38ffeb52..aa88f4ba 100755 --- a/tools/biosnoop.bt +++ b/tools/biosnoop.bt -@@ -1,5 +1,5 @@ - #!/usr/bin/env bpftrace --#include -+#include - /* - * biosnoop.bt Block I/O tracing tool, showing per I/O latency. - * For Linux, uses bpftrace, eBPF. -@@ -16,7 +16,7 @@ BEGIN +@@ -16,7 +16,8 @@ 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; -@@ -24,7 +24,7 @@ kprobe:blk_account_io_start +@@ -24,7 +25,8 @@ 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] != ""/ { diff --git a/tools/biostacks.bt b/tools/biostacks.bt -index 58201cdf..fdd2efed 100755 +index 58201cdf..1bc9f819 100755 --- a/tools/biostacks.bt +++ b/tools/biostacks.bt -@@ -18,7 +18,7 @@ BEGIN +@@ -18,7 +18,8 @@ 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; -- -2.34.1 +2.35.3 diff --git a/SOURCES/bpftrace-0.13.1-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch b/SOURCES/bpftrace-0.13.1-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch new file mode 100644 index 0000000..db5ba47 --- /dev/null +++ b/SOURCES/bpftrace-0.13.1-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch @@ -0,0 +1,98 @@ +From bcb8903067ce7a45b67ad0d5cabf83154b56d5ab Mon Sep 17 00:00:00 2001 +From: Viktor Malik +Date: Mon, 9 May 2022 07:58:46 +0200 +Subject: [PATCH 10/10] biosnoop.bt: handle Linux 5.17 block layer update + +The kernel upstream commit: + + https://github.com/torvalds/linux/commit/f3fa33acca9f0058157214800f68b10d8e71ab7a + +has removed the `rq_disk` field from `struct request`. Instead, +`->q->disk` should be used, so this is reflected in biosnoop.bt. + +The old version of the tool (suitable for kernel <= 5.16) is backed up +in tools/old and used in the CI. +--- + tools/biosnoop.bt | 2 +- + tools/old/biosnoop.bt | 56 +++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 57 insertions(+), 1 deletion(-) + create mode 100755 tools/old/biosnoop.bt + +diff --git a/tools/biosnoop.bt b/tools/biosnoop.bt +index 33ad75de..c00ef428 100755 +--- a/tools/biosnoop.bt ++++ b/tools/biosnoop.bt +@@ -25,7 +25,7 @@ kprobe:__blk_account_io_start + @start[arg0] = nsecs; + @iopid[arg0] = pid; + @iocomm[arg0] = comm; +- @disk[arg0] = ((struct request *)arg0)->rq_disk->disk_name; ++ @disk[arg0] = ((struct request *)arg0)->q->disk->disk_name; + } + + kprobe:blk_account_io_done, +diff --git a/tools/old/biosnoop.bt b/tools/old/biosnoop.bt +new file mode 100755 +index 00000000..1a99643a +--- /dev/null ++++ b/tools/old/biosnoop.bt +@@ -0,0 +1,56 @@ ++#!/usr/bin/env bpftrace ++/* ++ * biosnoop.bt Block I/O tracing tool, showing per I/O latency. ++ * For Linux, uses bpftrace, eBPF. ++ * ++ * TODO: switch to block tracepoints. Add offset and size columns. ++ * ++ * This is a bpftrace version of the bcc tool of the same name. ++ * ++ * For Linux <= 5.16. ++ * ++ * 15-Nov-2017 Brendan Gregg Created this. ++ */ ++ ++#ifndef BPFTRACE_HAVE_BTF ++#include ++#include ++#endif ++ ++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 ++{ ++ @start[arg0] = nsecs; ++ @iopid[arg0] = pid; ++ @iocomm[arg0] = comm; ++ @disk[arg0] = ((struct request *)arg0)->rq_disk->disk_name; ++} ++ ++kprobe:blk_account_io_done, ++kprobe:__blk_account_io_done ++/@start[arg0] != 0 && @iopid[arg0] != 0 && @iocomm[arg0] != ""/ ++ ++{ ++ $now = nsecs; ++ printf("%-12u %-7s %-16s %-6d %7d\n", ++ elapsed / 1e6, @disk[arg0], @iocomm[arg0], @iopid[arg0], ++ ($now - @start[arg0]) / 1e6); ++ ++ delete(@start[arg0]); ++ delete(@iopid[arg0]); ++ delete(@iocomm[arg0]); ++ delete(@disk[arg0]); ++} ++ ++END ++{ ++ clear(@start); ++ clear(@iopid); ++ clear(@iocomm); ++ clear(@disk); ++} +-- +2.35.3 + diff --git a/SOURCES/bpftrace-0.12.1-orc-Fix-build-with-clang-13.patch b/SOURCES/bpftrace-0.13.1-orc-Fix-build-with-clang-13.patch similarity index 87% rename from SOURCES/bpftrace-0.12.1-orc-Fix-build-with-clang-13.patch rename to SOURCES/bpftrace-0.13.1-orc-Fix-build-with-clang-13.patch index 2157003..07a3968 100644 --- a/SOURCES/bpftrace-0.12.1-orc-Fix-build-with-clang-13.patch +++ b/SOURCES/bpftrace-0.13.1-orc-Fix-build-with-clang-13.patch @@ -1,7 +1,7 @@ -From ddbd909505ed0530f0e4dec45c195e0cb315d516 Mon Sep 17 00:00:00 2001 +From f562f8fae4bdb8ac51fc815b725bfaada2371b31 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Sat, 4 Sep 2021 17:28:17 -0700 -Subject: [PATCH] orc: Fix build with clang >= 13 +Subject: [PATCH 3/6] orc: Fix build with clang >= 13 Fixes errors like src/ast/bpforc/bpforcv2.cpp:3:9: error: constructor for 'bpftrace::BpfOrc' must explicitly initialize the member 'ES' which does not have a default constructor @@ -17,7 +17,7 @@ Signed-off-by: Khem Raj 2 files changed, 37 insertions(+), 9 deletions(-) diff --git a/src/bpforc.h b/src/bpforc.h -index 5634c544..1900e497 100644 +index c333a651..cc6a1c97 100644 --- a/src/bpforc.h +++ b/src/bpforc.h @@ -20,6 +20,9 @@ @@ -30,7 +30,7 @@ index 5634c544..1900e497 100644 #endif #include -@@ -66,8 +69,12 @@ class BpfOrc +@@ -71,8 +74,12 @@ class BpfOrc std::unique_ptr TM; DataLayout DL; #if LLVM_VERSION_MAJOR >= 7 @@ -43,7 +43,7 @@ index 5634c544..1900e497 100644 #if LLVM_VERSION_MAJOR >= 7 && LLVM_VERSION_MAJOR < 12 std::shared_ptr Resolver; #endif -@@ -92,7 +99,21 @@ class BpfOrc +@@ -97,7 +104,21 @@ class BpfOrc #endif public: @@ -65,7 +65,7 @@ index 5634c544..1900e497 100644 void compile(std::unique_ptr M); /* Helper for creating a orc object, responsible for creating internal objects -@@ -125,7 +146,7 @@ class BpfOrc +@@ -130,7 +151,7 @@ class BpfOrc #ifdef LLVM_ORC_V2 Expected lookup(StringRef Name) { @@ -75,10 +75,10 @@ index 5634c544..1900e497 100644 #endif }; diff --git a/src/bpforcv2.cpp b/src/bpforcv2.cpp -index 209e08e5..104213b0 100644 +index 9876625b..3e6684e4 100644 --- a/src/bpforcv2.cpp +++ b/src/bpforcv2.cpp -@@ -1,24 +1,26 @@ +@@ -1,21 +1,23 @@ // Included by bpforc.cpp -BpfOrc::BpfOrc(TargetMachine *TM, DataLayout DL) @@ -103,15 +103,12 @@ index 209e08e5..104213b0 100644 - MainJD(cantFail(ES.createJITDylib("
"))) + MainJD(cantFail(this->ES->createJITDylib("
"))) { - MainJD.addGenerator( - cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess( - DL.getGlobalPrefix()))); } - LLVMContext &BpfOrc::getContext() { return *CTX.getContext(); -@@ -37,8 +39,13 @@ std::unique_ptr BpfOrc::Create() +@@ -34,8 +36,13 @@ std::unique_ptr BpfOrc::Create() // return unique_ptrs auto DL = cantFail(JTMB.getDefaultDataLayoutForTarget()); auto TM = cantFail(JTMB.createTargetMachine()); @@ -128,5 +125,5 @@ index 209e08e5..104213b0 100644 void BpfOrc::compile(std::unique_ptr M) -- -2.31.1 +2.35.3 diff --git a/SOURCES/bpftrace-0.13.1-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch b/SOURCES/bpftrace-0.13.1-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch new file mode 100644 index 0000000..2b1273d --- /dev/null +++ b/SOURCES/bpftrace-0.13.1-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch @@ -0,0 +1,285 @@ +From 9c9ac55573ac33abbbbad256eda08dafba18bf9f Mon Sep 17 00:00:00 2001 +From: Jerome Marchand +Date: Thu, 29 Apr 2021 12:03:28 +0200 +Subject: [PATCH 9/9] tools: Make tools rely on BTF instead of header files. + +Many distribution already ship BTF and this is more robust that +parsing header files. + +Fixes #1820 +--- + docs/reference_guide.md | 3 ++- + src/clang_parser.cpp | 4 ++++ + tools/biosnoop.bt | 5 ++++- + tools/dcsnoop.bt | 2 ++ + tools/mdflush.bt | 2 ++ + tools/naptime.bt | 2 ++ + tools/oomkill.bt | 2 ++ + tools/runqlen.bt | 6 ++++-- + tools/tcpaccept.bt | 4 ++++ + tools/tcpconnect.bt | 4 ++++ + tools/tcpdrop.bt | 4 ++++ + tools/tcplife.bt | 4 ++++ + tools/tcpretrans.bt | 4 ++++ + tools/tcpsynbl.bt | 2 ++ + 14 files changed, 44 insertions(+), 4 deletions(-) + +diff --git a/docs/reference_guide.md b/docs/reference_guide.md +index 69a8ed22..11a685de 100644 +--- a/docs/reference_guide.md ++++ b/docs/reference_guide.md +@@ -3455,7 +3455,8 @@ Attaching 1 probe... + # BTF Support + + If kernel has BTF, kernel types are automatically available and there is no need to include additional headers +-to use them. ++to use them. To allow users to detect this situation in scripts, the preprocessor macro `BPFTRACE_HAVE_BTF` ++is defined if BTF is detected. See tools/ for examples of its usage. + + Requirements for using BTF: + +diff --git a/src/clang_parser.cpp b/src/clang_parser.cpp +index 20269a71..7fb39949 100644 +--- a/src/clang_parser.cpp ++++ b/src/clang_parser.cpp +@@ -747,6 +747,9 @@ bool ClangParser::parse(ast::Program *program, BPFtrace &bpftrace, std::vector there's no reason to + // add the wokarounds for it + args.push_back("-D__CLANG_WORKAROUNDS_H"); ++ // Let script know we have BTF -- this is useful for prewritten tools to ++ // conditionally include headers if BTF isn't available. ++ args.push_back("-DBPFTRACE_HAVE_BTF"); + + if (handler.parse_file("definitions.h", input, args, input_files, false) && + handler.has_redefinition_error()) +@@ -779,6 +782,7 @@ bool ClangParser::parse(ast::Program *program, BPFtrace &bpftrace, std::vector + /* + * biosnoop.bt Block I/O tracing tool, showing per I/O latency. + * For Linux, uses bpftrace, eBPF. +@@ -11,6 +10,10 @@ + * 15-Nov-2017 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF ++#include ++#endif ++ + BEGIN + { + printf("%-12s %-7s %-16s %-6s %7s\n", "TIME(ms)", "DISK", "COMM", "PID", "LAT(ms)"); +diff --git a/tools/dcsnoop.bt b/tools/dcsnoop.bt +index 183f0fb5..e85ab1aa 100755 +--- a/tools/dcsnoop.bt ++++ b/tools/dcsnoop.bt +@@ -15,6 +15,7 @@ + * 08-Sep-2018 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include + +@@ -24,6 +25,7 @@ struct nameidata { + struct qstr last; + // [...] + }; ++#endif + + BEGIN + { +diff --git a/tools/mdflush.bt b/tools/mdflush.bt +index 541abba1..1db547f6 100755 +--- a/tools/mdflush.bt ++++ b/tools/mdflush.bt +@@ -13,8 +13,10 @@ + * 08-Sep-2018 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include ++#endif + + BEGIN + { +diff --git a/tools/naptime.bt b/tools/naptime.bt +index eb96b677..a84652a3 100755 +--- a/tools/naptime.bt ++++ b/tools/naptime.bt +@@ -13,8 +13,10 @@ + * 16-Feb-2019 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include ++#endif + + BEGIN + { +diff --git a/tools/oomkill.bt b/tools/oomkill.bt +index 6126682d..1c9b16a3 100755 +--- a/tools/oomkill.bt ++++ b/tools/oomkill.bt +@@ -20,7 +20,9 @@ + * 07-Sep-2018 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include ++#endif + + BEGIN + { +diff --git a/tools/runqlen.bt b/tools/runqlen.bt +index 02d82d74..1be42adc 100755 +--- a/tools/runqlen.bt ++++ b/tools/runqlen.bt +@@ -11,17 +11,19 @@ + * 07-Oct-2018 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + + // Until BTF is available, we'll need to declare some of this struct manually, + // since it isn't available to be #included. This will need maintenance to match + // your kernel version. It is from kernel/sched/sched.h: +-struct cfs_rq_partial { ++struct cfs_rq { + struct load_weight load; + unsigned long runnable_weight; + unsigned int nr_running; + unsigned int h_nr_running; + }; ++#endif + + BEGIN + { +@@ -31,7 +33,7 @@ BEGIN + profile:hz:99 + { + $task = (struct task_struct *)curtask; +- $my_q = (struct cfs_rq_partial *)$task->se.cfs_rq; ++ $my_q = (struct cfs_rq *)$task->se.cfs_rq; + $len = $my_q->nr_running; + $len = $len > 0 ? $len - 1 : 0; // subtract currently running task + @runqlen = lhist($len, 0, 100, 1); +diff --git a/tools/tcpaccept.bt b/tools/tcpaccept.bt +index b40a041b..2f4dfe1f 100755 +--- a/tools/tcpaccept.bt ++++ b/tools/tcpaccept.bt +@@ -16,8 +16,12 @@ + * 23-Nov-2018 Dale Hamel created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include ++#else ++#include ++#endif + + BEGIN + { +diff --git a/tools/tcpconnect.bt b/tools/tcpconnect.bt +index 4ae30d65..05c3ca0e 100755 +--- a/tools/tcpconnect.bt ++++ b/tools/tcpconnect.bt +@@ -19,8 +19,12 @@ + * 23-Nov-2018 Dale Hamel created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include ++#else ++#include ++#endif + + BEGIN + { +diff --git a/tools/tcpdrop.bt b/tools/tcpdrop.bt +index 79a86b08..2de3e507 100755 +--- a/tools/tcpdrop.bt ++++ b/tools/tcpdrop.bt +@@ -17,8 +17,12 @@ + * 23-Nov-2018 Dale Hamel created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include ++#else ++#include ++#endif + + BEGIN + { +diff --git a/tools/tcplife.bt b/tools/tcplife.bt +index 9c0d8814..a9a054bf 100755 +--- a/tools/tcplife.bt ++++ b/tools/tcplife.bt +@@ -13,10 +13,14 @@ + * 17-Apr-2019 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include + #include + #include ++#else ++#include ++#endif + + BEGIN + { +diff --git a/tools/tcpretrans.bt b/tools/tcpretrans.bt +index 8b9500c0..777d78fa 100755 +--- a/tools/tcpretrans.bt ++++ b/tools/tcpretrans.bt +@@ -17,8 +17,12 @@ + * 23-Nov-2018 Dale Hamel created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include + #include ++#else ++#include ++#endif + + BEGIN + { +diff --git a/tools/tcpsynbl.bt b/tools/tcpsynbl.bt +index 4b3c99c3..0570f29c 100755 +--- a/tools/tcpsynbl.bt ++++ b/tools/tcpsynbl.bt +@@ -13,7 +13,9 @@ + * 19-Apr-2019 Brendan Gregg Created this. + */ + ++#ifndef BPFTRACE_HAVE_BTF + #include ++#endif + + BEGIN + { +-- +2.35.3 + diff --git a/SPECS/bpftrace.spec b/SPECS/bpftrace.spec index 1a87ac1..e056cef 100644 --- a/SPECS/bpftrace.spec +++ b/SPECS/bpftrace.spec @@ -1,6 +1,6 @@ Name: bpftrace -Version: 0.12.1 -Release: 8%{?dist} +Version: 0.13.1 +Release: 1%{?dist} Summary: High-level tracing language for Linux eBPF License: ASL 2.0 @@ -9,10 +9,14 @@ Source0: %{url}/archive/v%{version}/%{name}-%{version}.tar.gz Patch0: %{name}-%{version}-RHEL-9-fixes.patch Patch1: %{name}-%{version}-Fix-mdflush.patch Patch2: %{name}-%{version}-orc-Fix-build-with-clang-13.patch -Patch3: %{name}-%{version}-Fix-single-arg-wildcard-listings.patch -Patch4: %{name}-%{version}-Update-bio-tools-to-work-on-RHEL9.patch +Patch3: %{name}-%{version}-Update-bio-tools-to-work-on-kernel-5.16.patch +Patch4: %{name}-%{version}-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch +Patch5: %{name}-%{version}-Fix-libbtf-0.6.0-build.patch +Patch6: %{name}-%{version}-Fix-compile-under-llvm14-trunk.patch +Patch7: %{name}-%{version}-Fix-LLVM-13-warnings.patch +Patch8: %{name}-%{version}-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch -Patch10: %{name}-%{version}-aarch64-fixes-statsnoop-and-opensnoop.patch +Patch10: %{name}-%{version}-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch # Arches will be included as upstream support is added and dependencies are # satisfied in the respective arches @@ -85,6 +89,10 @@ find %{buildroot}%{_datadir}/%{name}/tools -type f -exec \ %{_datadir}/%{name}/tools/doc/*.txt %changelog +* Mon May 16 2022 Jerome Marchand - 0.13.1-1 +- Rebase to bpftrace 0.13.1 +- Rebuild for LLVM14 + * Mon Feb 21 2022 Viktor Malik - 0.12.1-8 - Fix wildcard listing bug - Fix bio* tools