rpms
/
bcc
20
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

import bcc-0.25.0-2.el8

Browse Source
c8 imports/c8/bcc-0.25.0-2.el8
CentOS Sources 2 years ago committed by MSVSphere Packaging Team
commit 97a3296918
10 changed files with 2896 additions and 0 deletions
Show Stats Download Patch File Download Diff File

1
.bcc.metadata
Unescape View File

@ -0,0 +1 @@
059187f62e915eb74ea7b18e19fcb185f9d18255 SOURCES/bcc-0.25.0.tar.gz

1
.gitignore vendored
Unescape View File

@ -0,0 +1 @@
SOURCES/bcc-0.25.0.tar.gz

77
SOURCES/bcc-0.25.0-Fix-bpf_pseudo_fd-type-conversion-error.patch
Unescape View File

@ -0,0 +1,77 @@
From 728005aac7c23590a406ac67235d915e416bff5d Mon Sep 17 00:00:00 2001
From: Yonghong Song <yhs@fb.com>
Date: Sat, 13 Aug 2022 17:50:07 -0700
Subject: [PATCH 1/2] Fix bpf_pseudo_fd() type conversion error
With llvm15 and llvm16, the following command line
sudo ./trace.py 'smp_call_function_single "%K", arg1'
will cause error:
/virtual/main.c:60:36: error: incompatible integer to pointer conversion passing 'u64'
(aka 'unsigned long long') to parameter of type 'void *' [-Wint-conversion]
bpf_perf_event_output(ctx, bpf_pseudo_fd(1, -1), CUR_CPU_IDENTIFIER, &__data, sizeof(__data));
^~~~~~~~~~~~~~~~~~~~
1 error generated.
Failed to compile BPF module <text>
In helpers.h, we have
u64 bpf_pseudo_fd(u64, u64) asm("llvm.bpf.pseudo");
Apparently, <= llvm14 can tolerate u64 -> 'void *' conversion, but
llvm15 by default will cause an error.
Let us explicitly convert bpf_pseudo_fd to 'void *' to avoid
such errors.
Signed-off-by: Yonghong Song <yhs@fb.com>
---
src/cc/frontends/clang/b_frontend_action.cc | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc
index a4e05b16..dbeba3e4 100644
--- a/src/cc/frontends/clang/b_frontend_action.cc
+++ b/src/cc/frontends/clang/b_frontend_action.cc
@@ -957,7 +957,7 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) {
string arg0 = rewriter_.getRewrittenText(expansionRange(Call->getArg(0)->getSourceRange()));
string args_other = rewriter_.getRewrittenText(expansionRange(SourceRange(GET_BEGINLOC(Call->getArg(1)),
GET_ENDLOC(Call->getArg(2)))));
- txt = "bpf_perf_event_output(" + arg0 + ", bpf_pseudo_fd(1, " + fd + ")";
+ txt = "bpf_perf_event_output(" + arg0 + ", (void *)bpf_pseudo_fd(1, " + fd + ")";
txt += ", CUR_CPU_IDENTIFIER, " + args_other + ")";
// e.g.
@@ -986,7 +986,7 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) {
string meta_len = rewriter_.getRewrittenText(expansionRange(Call->getArg(3)->getSourceRange()));
txt = "bpf_perf_event_output(" +
skb + ", " +
- "bpf_pseudo_fd(1, " + fd + "), " +
+ "(void *)bpf_pseudo_fd(1, " + fd + "), " +
"((__u64)" + skb_len + " << 32) | BPF_F_CURRENT_CPU, " +
meta + ", " +
meta_len + ");";
@@ -1006,12 +1006,12 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) {
string keyp = rewriter_.getRewrittenText(expansionRange(Call->getArg(1)->getSourceRange()));
string flag = rewriter_.getRewrittenText(expansionRange(Call->getArg(2)->getSourceRange()));
txt = "bpf_" + string(memb_name) + "(" + ctx + ", " +
- "bpf_pseudo_fd(1, " + fd + "), " + keyp + ", " + flag + ");";
+ "(void *)bpf_pseudo_fd(1, " + fd + "), " + keyp + ", " + flag + ");";
} else if (memb_name == "ringbuf_output") {
string name = string(Ref->getDecl()->getName());
string args = rewriter_.getRewrittenText(expansionRange(SourceRange(GET_BEGINLOC(Call->getArg(0)),
GET_ENDLOC(Call->getArg(2)))));
- txt = "bpf_ringbuf_output(bpf_pseudo_fd(1, " + fd + ")";
+ txt = "bpf_ringbuf_output((void *)bpf_pseudo_fd(1, " + fd + ")";
txt += ", " + args + ")";
// e.g.
@@ -1033,7 +1033,7 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) {
} else if (memb_name == "ringbuf_reserve") {
string name = string(Ref->getDecl()->getName());
string arg0 = rewriter_.getRewrittenText(expansionRange(Call->getArg(0)->getSourceRange()));
- txt = "bpf_ringbuf_reserve(bpf_pseudo_fd(1, " + fd + ")";
+ txt = "bpf_ringbuf_reserve((void *)bpf_pseudo_fd(1, " + fd + ")";
txt += ", " + arg0 + ", 0)"; // Flags in reserve are meaningless
} else if (memb_name == "ringbuf_discard") {
string name = string(Ref->getDecl()->getName());
--
2.38.1

96
SOURCES/bcc-0.25.0-Fix-clang-15-int-to-pointer-conversion-errors.patch
Unescape View File

@ -0,0 +1,96 @@
From f5a6c22f613d0566ba542f38f349be379e3844e8 Mon Sep 17 00:00:00 2001
From: Jerome Marchand <jmarchan@redhat.com>
Date: Wed, 26 Oct 2022 14:41:54 +0200
Subject: [PATCH 2/2] Fix clang 15 int to pointer conversion errors
Since version 15, clang issues error for implicit conversion of
integer to pointer. Several tools are broken. This patch add explicit
pointer cast where needed.
Fixes the following errors:
/virtual/main.c:37:18: error: incompatible integer to pointer conversion initializing 'struct request *' with an expression of type 'unsigned long' [-Wint-conversion]
struct request *req = ctx->di;
^ ~~~~~~~
/virtual/main.c:49:18: error: incompatible integer to pointer conversion initializing 'struct request *' with an expression of type 'unsigned long' [-Wint-conversion]
struct request *req = ctx->di;
^ ~~~~~~~
2 errors generated.
/virtual/main.c:73:19: error: incompatible integer to pointer conversion initializing 'struct pt_regs *' with an expression of type 'unsigned long' [-Wint-conversion]
struct pt_regs * __ctx = ctx->di;
^ ~~~~~~~
/virtual/main.c:100:240: error: incompatible integer to pointer conversion passing 'u64' (aka 'unsigned long long') to parameter of type 'const void *' [-Wint-conversion]
data.ppid = ({ typeof(pid_t) _val; __builtin_memset(&_val, 0, sizeof(_val)); bpf_probe_read(&_val, sizeof(_val), (u64)&({ typeof(struct task_struct *) _val; __builtin_memset(&_val, 0, sizeof(_val)); bpf_probe_read(&_val, sizeof(_val), (u64)&task->real_parent); _val; })->tgid); _val; });
^~~~~~~~~~~~~~~~~~~~~~~
/virtual/main.c:100:118: error: incompatible integer to pointer conversion passing 'u64' (aka 'unsigned long long') to parameter of type 'const void *' [-Wint-conversion]
data.ppid = ({ typeof(pid_t) _val; __builtin_memset(&_val, 0, sizeof(_val)); bpf_probe_read(&_val, sizeof(_val), (u64)&({ typeof(struct task_struct *) _val; __builtin_memset(&_val, 0, sizeof(_val)); bpf_probe_read(&_val, sizeof(_val), (u64)&task->real_parent); _val; })->tgid); _val; });
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Signed-off-by: Jerome Marchand <jmarchan@redhat.com>
---
src/cc/frontends/clang/b_frontend_action.cc | 18 +++++++++---------
1 file changed, 9 insertions(+), 9 deletions(-)
diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc
index dbeba3e4..c0582464 100644
--- a/src/cc/frontends/clang/b_frontend_action.cc
+++ b/src/cc/frontends/clang/b_frontend_action.cc
@@ -517,9 +517,9 @@ bool ProbeVisitor::VisitUnaryOperator(UnaryOperator *E) {
string pre, post;
pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));";
if (cannot_fall_back_safely)
- pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)";
+ pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (void *)";
else
- pre += " bpf_probe_read(&_val, sizeof(_val), (u64)";
+ pre += " bpf_probe_read(&_val, sizeof(_val), (void *)";
post = "); _val; })";
rewriter_.ReplaceText(expansionLoc(E->getOperatorLoc()), 1, pre);
rewriter_.InsertTextAfterToken(expansionLoc(GET_ENDLOC(sub)), post);
@@ -581,9 +581,9 @@ bool ProbeVisitor::VisitMemberExpr(MemberExpr *E) {
string pre, post;
pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));";
if (cannot_fall_back_safely)
- pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)&";
+ pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (void *)&";
else
- pre += " bpf_probe_read(&_val, sizeof(_val), (u64)&";
+ pre += " bpf_probe_read(&_val, sizeof(_val), (void *)&";
post = rhs + "); _val; })";
rewriter_.InsertText(expansionLoc(GET_BEGINLOC(E)), pre);
rewriter_.ReplaceText(expansionRange(SourceRange(member, GET_ENDLOC(E))), post);
@@ -635,9 +635,9 @@ bool ProbeVisitor::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));";
if (cannot_fall_back_safely)
- pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)((";
+ pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (void *)((";
else
- pre += " bpf_probe_read(&_val, sizeof(_val), (u64)((";
+ pre += " bpf_probe_read(&_val, sizeof(_val), (void *)((";
if (isMemberDereference(base)) {
pre += "&";
// If the base of the array subscript is a member dereference, we'll rewrite
@@ -747,8 +747,8 @@ void BTypeVisitor::genParamDirectAssign(FunctionDecl *D, string& preamble,
arg->addAttr(UnavailableAttr::CreateImplicit(C, "ptregs"));
size_t d = idx - 1;
const char *reg = calling_conv_regs[d];
- preamble += " " + text + " = " + fn_args_[0]->getName().str() + "->" +
- string(reg) + ";";
+ preamble += " " + text + " = (" + arg->getType().getAsString() + ")" +
+ fn_args_[0]->getName().str() + "->" + string(reg) + ";";
}
}
}
@@ -762,7 +762,7 @@ void BTypeVisitor::genParamIndirectAssign(FunctionDecl *D, string& preamble,
if (idx == 0) {
new_ctx = "__" + arg->getName().str();
- preamble += " struct pt_regs * " + new_ctx + " = " +
+ preamble += " struct pt_regs * " + new_ctx + " = (void *)" +
arg->getName().str() + "->" +
string(calling_conv_regs[0]) + ";";
} else {
--
2.38.1

30
SOURCES/bcc-0.25.0-Fix-get_kprobe_functions.patch
Unescape View File

@ -0,0 +1,30 @@
From c27899b15bca6188d34c0b87b3389eeda2a90cb5 Mon Sep 17 00:00:00 2001
From: Jerome Marchand <jmarchan@redhat.com>
Date: Mon, 9 Jan 2023 18:17:20 +0100
Subject: [PATCH] Fix get_kprobe_functions
get_kprobe_functions will not only return a function that matches the
regular expression, but also any function that starts with a
substrings that matches it. This is obviously not the intended
behavior.
The issue is easily fixed by replacing re.match by re.fullmatch.
---
src/python/bcc/__init__.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py
index 7175b98e..970ddcc2 100644
--- a/src/python/bcc/__init__.py
+++ b/src/python/bcc/__init__.py
@@ -745,7 +745,7 @@ DEBUG_BTF = 0x20
# Exclude all gcc 8's extra .cold functions
elif re.match(b'^.*\.cold(\.\d+)?$', fn):
continue
- if (t.lower() in [b't', b'w']) and re.match(event_re, fn) \
+ if (t.lower() in [b't', b'w']) and re.fullmatch(event_re, fn) \
and fn not in blacklist:
fns.append(fn)
return set(fns) # Some functions may appear more than once
--
2.38.1

1480
SOURCES/bcc-0.25.0-Manpages-remove-unstable-statement.patch
View File

File diff suppressed because it is too large Load Diff

684
SOURCES/bcc-0.25.0-RHEL-libbpf-version-fixes.patch
Unescape View File

@ -0,0 +1,684 @@
From 66d9bffa99738bbed50b3d5b2d87990cdb5e4a58 Mon Sep 17 00:00:00 2001
From: Jerome Marchand <jmarchan@redhat.com>
Date: Mon, 28 Nov 2022 12:23:59 +0100
Subject: [PATCH] RHEL: libbpf version fixes
Revert "[bcc] stop using deprecated `bpf_load_program_attr`"
Revert "backport `struct bpf_create_map_attr`"
Revert "bcc: Replace deprecated libbpf API"
Revert "bcc: Replace deprecated libbpf APIs" since the libbpf version
provided in RHEL 8 doesn't provide the new APIs.
Remove BPF_MAP_TYPE_BLOOM_FILTER from bps since the libbpf version in
RHEL 8, doesn't provide bloom filter map.
Rename btf__load_vmlinux_btf into libbpf_find_kernel_btf. The function
has been renamed upstream for naming consistency, but RHEL 8 libbpf
still uses the old name.
Also use the older btf__get_nr_types() instead of btf__type_cnt() for
the same reason.
Add definition of struct bpf_core_relo.
---
introspection/bps.c | 1 -
libbpf-tools/ksnoop.c | 4 +-
src/cc/bcc_btf.cc | 73 +++++++++++++++-
src/cc/bpf_module.cc | 38 ++++----
src/cc/common.cc | 4 +-
src/cc/libbpf.c | 196 +++++++++++++++---------------------------
src/cc/libbpf.h | 28 ++----
7 files changed, 169 insertions(+), 175 deletions(-)
diff --git a/introspection/bps.c b/introspection/bps.c
index 232b23d4..6ec02e6c 100644
--- a/introspection/bps.c
+++ b/introspection/bps.c
@@ -80,7 +80,6 @@ static const char * const map_type_strings[] = {
[BPF_MAP_TYPE_RINGBUF] = "ringbuf",
[BPF_MAP_TYPE_INODE_STORAGE] = "inode_storage",
[BPF_MAP_TYPE_TASK_STORAGE] = "task_storage",
- [BPF_MAP_TYPE_BLOOM_FILTER] = "bloom_filter",
};
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
diff --git a/libbpf-tools/ksnoop.c b/libbpf-tools/ksnoop.c
index 87fe175c..960e901b 100644
--- a/libbpf-tools/ksnoop.c
+++ b/libbpf-tools/ksnoop.c
@@ -347,7 +347,7 @@ static struct btf *get_btf(const char *name)
name && strlen(name) > 0 ? name : "vmlinux");
if (!vmlinux_btf) {
- vmlinux_btf = btf__load_vmlinux_btf();
+ vmlinux_btf = libbpf_find_kernel_btf();
if (!vmlinux_btf) {
err = -errno;
p_err("No BTF, cannot determine type info: %s", strerror(-err));
@@ -357,7 +357,7 @@ static struct btf *get_btf(const char *name)
if (!name || strlen(name) == 0)
return vmlinux_btf;
- mod_btf = btf__load_module_btf(name, vmlinux_btf);
+ mod_btf = libbpf_find_kernel_btf(name, vmlinux_btf);
if (!mod_btf) {
err = -errno;
p_err("No BTF for module '%s': %s", name, strerror(-err));
diff --git a/src/cc/bcc_btf.cc b/src/cc/bcc_btf.cc
index be248612..74fc902c 100644
--- a/src/cc/bcc_btf.cc
+++ b/src/cc/bcc_btf.cc
@@ -170,6 +170,77 @@ static int btf_ext_setup_line_info(struct btf_ext *btf_ext)
return btf_ext_setup_info(btf_ext, &param);
}
+/* bpf_core_relo_kind encodes which aspect of captured field/type/enum value
+ * has to be adjusted by relocations.
+ */
+enum bpf_core_relo_kind {
+ BPF_FIELD_BYTE_OFFSET = 0, /* field byte offset */
+ BPF_FIELD_BYTE_SIZE = 1, /* field size in bytes */
+ BPF_FIELD_EXISTS = 2, /* field existence in target kernel */
+ BPF_FIELD_SIGNED = 3, /* field signedness (0 - unsigned, 1 - signed) */
+ BPF_FIELD_LSHIFT_U64 = 4, /* bitfield-specific left bitshift */
+ BPF_FIELD_RSHIFT_U64 = 5, /* bitfield-specific right bitshift */
+ BPF_TYPE_ID_LOCAL = 6, /* type ID in local BPF object */
+ BPF_TYPE_ID_TARGET = 7, /* type ID in target kernel */
+ BPF_TYPE_EXISTS = 8, /* type existence in target kernel */
+ BPF_TYPE_SIZE = 9, /* type size in bytes */
+ BPF_ENUMVAL_EXISTS = 10, /* enum value existence in target kernel */
+ BPF_ENUMVAL_VALUE = 11, /* enum value integer value */
+};
+
+/* The minimum bpf_core_relo checked by the loader
+ *
+ * CO-RE relocation captures the following data:
+ * - insn_off - instruction offset (in bytes) within a BPF program that needs
+ * its insn->imm field to be relocated with actual field info;
+ * - type_id - BTF type ID of the "root" (containing) entity of a relocatable
+ * type or field;
+ * - access_str_off - offset into corresponding .BTF string section. String
+ * interpretation depends on specific relocation kind:
+ * - for field-based relocations, string encodes an accessed field using
+ * a sequence of field and array indices, separated by colon (:). It's
+ * conceptually very close to LLVM's getelementptr ([0]) instruction's
+ * arguments for identifying offset to a field.
+ * - for type-based relocations, strings is expected to be just "0";
+ * - for enum value-based relocations, string contains an index of enum
+ * value within its enum type;
+ *
+ * Example to provide a better feel.
+ *
+ * struct sample {
+ * int a;
+ * struct {
+ * int b[10];
+ * };
+ * };
+ *
+ * struct sample *s = ...;
+ * int x = &s->a; // encoded as "0:0" (a is field #0)
+ * int y = &s->b[5]; // encoded as "0:1:0:5" (anon struct is field #1,
+ * // b is field #0 inside anon struct, accessing elem #5)
+ * int z = &s[10]->b; // encoded as "10:1" (ptr is used as an array)
+ *
+ * type_id for all relocs in this example will capture BTF type id of
+ * `struct sample`.
+ *
+ * Such relocation is emitted when using __builtin_preserve_access_index()
+ * Clang built-in, passing expression that captures field address, e.g.:
+ *
+ * bpf_probe_read(&dst, sizeof(dst),
+ * __builtin_preserve_access_index(&src->a.b.c));
+ *
+ * In this case Clang will emit field relocation recording necessary data to
+ * be able to find offset of embedded `a.b.c` field within `src` struct.
+ *
+ * [0] https://llvm.org/docs/LangRef.html#getelementptr-instruction
+ */
+struct bpf_core_relo {
+ __u32 insn_off;
+ __u32 type_id;
+ __u32 access_str_off;
+ enum bpf_core_relo_kind kind;
+};
+
static int btf_ext_setup_core_relos(struct btf_ext *btf_ext)
{
struct btf_ext_sec_setup_param param = {
@@ -597,7 +668,7 @@ int BTF::load(uint8_t *btf_sec, uintptr_t btf_sec_size,
return -1;
}
- if (btf__load_into_kernel(btf)) {
+ if (btf__load(btf)) {
btf__free(btf);
warning("Loading .BTF section failed\n");
return -1;
diff --git a/src/cc/bpf_module.cc b/src/cc/bpf_module.cc
index 86f6a228..490fffe8 100644
--- a/src/cc/bpf_module.cc
+++ b/src/cc/bpf_module.cc
@@ -407,7 +407,7 @@ int BPFModule::create_maps(std::map<std::string, std::pair<int, int>> &map_tids,
}
if (pinned_id <= 0) {
- struct bcc_create_map_attr attr = {};
+ struct bpf_create_map_attr attr = {};
attr.map_type = (enum bpf_map_type)map_type;
attr.name = map_name;
attr.key_size = key_size;
@@ -982,22 +982,26 @@ int BPFModule::bcc_func_load(int prog_type, const char *name,
const char *license, unsigned kern_version,
int log_level, char *log_buf, unsigned log_buf_size,
const char *dev_name, unsigned flags, int expected_attach_type) {
- struct bpf_prog_load_opts opts = {};
+ struct bpf_load_program_attr attr = {};
unsigned func_info_cnt, line_info_cnt, finfo_rec_size, linfo_rec_size;
void *func_info = NULL, *line_info = NULL;
int ret;
+ attr.prog_type = (enum bpf_prog_type)prog_type;
if (expected_attach_type != -1) {
- opts.expected_attach_type = (enum bpf_attach_type)expected_attach_type;
+ attr.expected_attach_type = (enum bpf_attach_type)expected_attach_type;
}
- if (prog_type != BPF_PROG_TYPE_TRACING &&
- prog_type != BPF_PROG_TYPE_EXT) {
- opts.kern_version = kern_version;
+ attr.name = name;
+ attr.insns = insns;
+ attr.license = license;
+ if (attr.prog_type != BPF_PROG_TYPE_TRACING &&
+ attr.prog_type != BPF_PROG_TYPE_EXT) {
+ attr.kern_version = kern_version;
}
- opts.prog_flags = flags;
- opts.log_level = log_level;
+ attr.prog_flags = flags;
+ attr.log_level = log_level;
if (dev_name)
- opts.prog_ifindex = if_nametoindex(dev_name);
+ attr.prog_ifindex = if_nametoindex(dev_name);
if (btf_) {
int btf_fd = btf_->get_fd();
@@ -1008,17 +1012,17 @@ int BPFModule::bcc_func_load(int prog_type, const char *name,
&finfo_rec_size, &line_info,
&line_info_cnt, &linfo_rec_size);
if (!ret) {
- opts.prog_btf_fd = btf_fd;
- opts.func_info = func_info;
- opts.func_info_cnt = func_info_cnt;
- opts.func_info_rec_size = finfo_rec_size;
- opts.line_info = line_info;
- opts.line_info_cnt = line_info_cnt;
- opts.line_info_rec_size = linfo_rec_size;
+ attr.prog_btf_fd = btf_fd;
+ attr.func_info = func_info;
+ attr.func_info_cnt = func_info_cnt;
+ attr.func_info_rec_size = finfo_rec_size;
+ attr.line_info = line_info;
+ attr.line_info_cnt = line_info_cnt;
+ attr.line_info_rec_size = linfo_rec_size;
}
}
- ret = bcc_prog_load_xattr((enum bpf_prog_type)prog_type, name, license, insns, &opts, prog_len, log_buf, log_buf_size, allow_rlimit_);
+ ret = bcc_prog_load_xattr(&attr, prog_len, log_buf, log_buf_size, allow_rlimit_);
if (btf_) {
free(func_info);
free(line_info);
diff --git a/src/cc/common.cc b/src/cc/common.cc
index 3143adb0..11970275 100644
--- a/src/cc/common.cc
+++ b/src/cc/common.cc
@@ -34,11 +34,11 @@ using std::experimental::optional;
static optional<int32_t> get_enum_val_from_btf(const char *name) {
optional<int32_t> val;
- auto btf = btf__load_vmlinux_btf();
+ auto btf = libbpf_find_kernel_btf();
if (libbpf_get_error(btf))
return {};
- for (size_t i = 1; i < btf__type_cnt(btf); i++) {
+ for (size_t i = 1; i <= btf__get_nr_types(btf); i++) {
auto t = btf__type_by_id(btf, i);
if (btf_kind(t) != BTF_KIND_ENUM)
continue;
diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c
index 0c09f9b3..7042c792 100644
--- a/src/cc/libbpf.c
+++ b/src/cc/libbpf.c
@@ -319,33 +319,14 @@ static uint64_t ptr_to_u64(void *ptr)
return (uint64_t) (unsigned long) ptr;
}
-static int libbpf_bpf_map_create(struct bcc_create_map_attr *create_attr)
-{
- LIBBPF_OPTS(bpf_map_create_opts, p);
-
- p.map_flags = create_attr->map_flags;
- p.numa_node = create_attr->numa_node;
- p.btf_fd = create_attr->btf_fd;
- p.btf_key_type_id = create_attr->btf_key_type_id;
- p.btf_value_type_id = create_attr->btf_value_type_id;
- p.map_ifindex = create_attr->map_ifindex;
- if (create_attr->map_type == BPF_MAP_TYPE_STRUCT_OPS)
- p.btf_vmlinux_value_type_id = create_attr->btf_vmlinux_value_type_id;
- else
- p.inner_map_fd = create_attr->inner_map_fd;
-
- return bpf_map_create(create_attr->map_type, create_attr->name, create_attr->key_size,
- create_attr->value_size, create_attr->max_entries, &p);
-}
-
-int bcc_create_map_xattr(struct bcc_create_map_attr *attr, bool allow_rlimit)
+int bcc_create_map_xattr(struct bpf_create_map_attr *attr, bool allow_rlimit)
{
unsigned name_len = attr->name ? strlen(attr->name) : 0;
char map_name[BPF_OBJ_NAME_LEN] = {};
memcpy(map_name, attr->name, min(name_len, BPF_OBJ_NAME_LEN - 1));
attr->name = map_name;
- int ret = libbpf_bpf_map_create(attr);
+ int ret = bpf_create_map_xattr(attr);
if (ret < 0 && errno == EPERM) {
if (!allow_rlimit)
@@ -357,7 +338,7 @@ int bcc_create_map_xattr(struct bcc_create_map_attr *attr, bool allow_rlimit)
rl.rlim_max = RLIM_INFINITY;
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_MEMLOCK, &rl) == 0)
- ret = libbpf_bpf_map_create(attr);
+ ret = bpf_create_map_xattr(attr);
}
}
@@ -367,12 +348,12 @@ int bcc_create_map_xattr(struct bcc_create_map_attr *attr, bool allow_rlimit)
attr->btf_fd = 0;
attr->btf_key_type_id = 0;
attr->btf_value_type_id = 0;
- ret = libbpf_bpf_map_create(attr);
+ ret = bpf_create_map_xattr(attr);
}
if (ret < 0 && name_len && (errno == E2BIG || errno == EINVAL)) {
map_name[0] = '\0';
- ret = libbpf_bpf_map_create(attr);
+ ret = bpf_create_map_xattr(attr);
}
if (ret < 0 && errno == EPERM) {
@@ -385,7 +366,7 @@ int bcc_create_map_xattr(struct bcc_create_map_attr *attr, bool allow_rlimit)
rl.rlim_max = RLIM_INFINITY;
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_MEMLOCK, &rl) == 0)
- ret = libbpf_bpf_map_create(attr);
+ ret = bpf_create_map_xattr(attr);
}
}
return ret;
@@ -395,7 +376,7 @@ int bcc_create_map(enum bpf_map_type map_type, const char *name,
int key_size, int value_size,
int max_entries, int map_flags)
{
- struct bcc_create_map_attr attr = {};
+ struct bpf_create_map_attr attr = {};
attr.map_type = map_type;
attr.name = name;
@@ -644,70 +625,24 @@ int bpf_prog_get_tag(int fd, unsigned long long *ptag)
return -2;
}
-static int libbpf_bpf_prog_load(enum bpf_prog_type prog_type,
- const char *prog_name, const char *license,
- const struct bpf_insn *insns, size_t insn_cnt,
- struct bpf_prog_load_opts *opts,
- char *log_buf, size_t log_buf_sz)
-{
-
- LIBBPF_OPTS(bpf_prog_load_opts, p);
-
- if (!opts || !log_buf != !log_buf_sz) {
- errno = EINVAL;
- return -EINVAL;
- }
-
- p.expected_attach_type = opts->expected_attach_type;
- switch (prog_type) {
- case BPF_PROG_TYPE_STRUCT_OPS:
- case BPF_PROG_TYPE_LSM:
- p.attach_btf_id = opts->attach_btf_id;
- break;
- case BPF_PROG_TYPE_TRACING:
- case BPF_PROG_TYPE_EXT:
- p.attach_btf_id = opts->attach_btf_id;
- p.attach_prog_fd = opts->attach_prog_fd;
- break;
- default:
- p.prog_ifindex = opts->prog_ifindex;
- p.kern_version = opts->kern_version;
- }
- p.log_level = opts->log_level;
- p.log_buf = log_buf;
- p.log_size = log_buf_sz;
- p.prog_btf_fd = opts->prog_btf_fd;
- p.func_info_rec_size = opts->func_info_rec_size;
- p.func_info_cnt = opts->func_info_cnt;
- p.func_info = opts->func_info;
- p.line_info_rec_size = opts->line_info_rec_size;
- p.line_info_cnt = opts->line_info_cnt;
- p.line_info = opts->line_info;
- p.prog_flags = opts->prog_flags;
-
- return bpf_prog_load(prog_type, prog_name, license,
- insns, insn_cnt, &p);
-}
-
-int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
- const char *license, const struct bpf_insn *insns,
- struct bpf_prog_load_opts *opts, int prog_len,
+int bcc_prog_load_xattr(struct bpf_load_program_attr *attr, int prog_len,
char *log_buf, unsigned log_buf_size, bool allow_rlimit)
{
- unsigned name_len = prog_name ? strlen(prog_name) : 0;
- char *tmp_log_buf = NULL, *opts_log_buf = NULL;
- unsigned tmp_log_buf_size = 0, opts_log_buf_size = 0;
+ unsigned name_len = attr->name ? strlen(attr->name) : 0;
+ char *tmp_log_buf = NULL, *attr_log_buf = NULL;
+ unsigned tmp_log_buf_size = 0, attr_log_buf_size = 0;
int ret = 0, name_offset = 0, expected_attach_type = 0;
- char new_prog_name[BPF_OBJ_NAME_LEN] = {};
+ char prog_name[BPF_OBJ_NAME_LEN] = {};
unsigned insns_cnt = prog_len / sizeof(struct bpf_insn);
+ attr->insns_cnt = insns_cnt;
- if (opts->log_level > 0) {
+ if (attr->log_level > 0) {
if (log_buf_size > 0) {
// Use user-provided log buffer if available.
log_buf[0] = 0;
- opts_log_buf = log_buf;
- opts_log_buf_size = log_buf_size;
+ attr_log_buf = log_buf;
+ attr_log_buf_size = log_buf_size;
} else {
// Create and use temporary log buffer if user didn't provide one.
tmp_log_buf_size = LOG_BUF_SIZE;
@@ -715,82 +650,82 @@ int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
if (!tmp_log_buf) {
fprintf(stderr, "bpf: Failed to allocate temporary log buffer: %s\n\n",
strerror(errno));
- opts->log_level = 0;
+ attr->log_level = 0;
} else {
tmp_log_buf[0] = 0;
- opts_log_buf = tmp_log_buf;
- opts_log_buf_size = tmp_log_buf_size;
+ attr_log_buf = tmp_log_buf;
+ attr_log_buf_size = tmp_log_buf_size;
}
}
}
-
if (name_len) {
- if (strncmp(prog_name, "kprobe__", 8) == 0)
+ if (strncmp(attr->name, "kprobe__", 8) == 0)
name_offset = 8;
- else if (strncmp(prog_name, "kretprobe__", 11) == 0)
+ else if (strncmp(attr->name, "kretprobe__", 11) == 0)
name_offset = 11;
- else if (strncmp(prog_name, "tracepoint__", 12) == 0)
+ else if (strncmp(attr->name, "tracepoint__", 12) == 0)
name_offset = 12;
- else if (strncmp(prog_name, "raw_tracepoint__", 16) == 0)
+ else if (strncmp(attr->name, "raw_tracepoint__", 16) == 0)
name_offset = 16;
- else if (strncmp(prog_name, "kfunc__", 7) == 0) {
+ else if (strncmp(attr->name, "kfunc__", 7) == 0) {
name_offset = 7;
expected_attach_type = BPF_TRACE_FENTRY;
- } else if (strncmp(prog_name, "kmod_ret__", 10) == 0) {
+ } else if (strncmp(attr->name, "kmod_ret__", 10) == 0) {
name_offset = 10;
expected_attach_type = BPF_MODIFY_RETURN;
- } else if (strncmp(prog_name, "kretfunc__", 10) == 0) {
+ } else if (strncmp(attr->name, "kretfunc__", 10) == 0) {
name_offset = 10;
expected_attach_type = BPF_TRACE_FEXIT;
- } else if (strncmp(prog_name, "lsm__", 5) == 0) {
+ } else if (strncmp(attr->name, "lsm__", 5) == 0) {
name_offset = 5;
expected_attach_type = BPF_LSM_MAC;
- } else if (strncmp(prog_name, "bpf_iter__", 10) == 0) {
+ } else if (strncmp(attr->name, "bpf_iter__", 10) == 0) {
name_offset = 10;
expected_attach_type = BPF_TRACE_ITER;
}
- if (prog_type == BPF_PROG_TYPE_TRACING ||
- prog_type == BPF_PROG_TYPE_LSM) {
- ret = libbpf_find_vmlinux_btf_id(prog_name + name_offset,
+ if (attr->prog_type == BPF_PROG_TYPE_TRACING ||
+ attr->prog_type == BPF_PROG_TYPE_LSM) {
+ ret = libbpf_find_vmlinux_btf_id(attr->name + name_offset,
expected_attach_type);
if (ret == -EINVAL) {
fprintf(stderr, "bpf: vmlinux BTF is not found\n");
return ret;
} else if (ret < 0) {
fprintf(stderr, "bpf: %s is not found in vmlinux BTF\n",
- prog_name + name_offset);
+ attr->name + name_offset);
return ret;
}
- opts->attach_btf_id = ret;
- opts->expected_attach_type = expected_attach_type;
+ attr->attach_btf_id = ret;
+ attr->expected_attach_type = expected_attach_type;
}
- memcpy(new_prog_name, prog_name + name_offset,
+ memcpy(prog_name, attr->name + name_offset,
min(name_len - name_offset, BPF_OBJ_NAME_LEN - 1));
+ attr->name = prog_name;
}
- ret = libbpf_bpf_prog_load(prog_type, new_prog_name, license, insns, insns_cnt, opts, opts_log_buf, opts_log_buf_size);
+ ret = bpf_load_program_xattr(attr, attr_log_buf, attr_log_buf_size);
// func_info/line_info may not be supported in old kernels.
- if (ret < 0 && opts->func_info && errno == EINVAL) {
- opts->prog_btf_fd = 0;
- opts->func_info = NULL;
- opts->func_info_cnt = 0;
- opts->func_info_rec_size = 0;
- opts->line_info = NULL;
- opts->line_info_cnt = 0;
- opts->line_info_rec_size = 0;
- ret = libbpf_bpf_prog_load(prog_type, new_prog_name, license, insns, insns_cnt, opts, opts_log_buf, opts_log_buf_size);
+ if (ret < 0 && attr->func_info && errno == EINVAL) {
+ attr->prog_btf_fd = 0;
+ attr->func_info = NULL;
+ attr->func_info_cnt = 0;
+ attr->func_info_rec_size = 0;
+ attr->line_info = NULL;
+ attr->line_info_cnt = 0;
+ attr->line_info_rec_size = 0;
+ ret = bpf_load_program_xattr(attr, attr_log_buf, attr_log_buf_size);
}
// BPF object name is not supported on older Kernels.
// If we failed due to this, clear the name and try again.
if (ret < 0 && name_len && (errno == E2BIG || errno == EINVAL)) {
- new_prog_name[0] = '\0';
- ret = libbpf_bpf_prog_load(prog_type, new_prog_name, license, insns, insns_cnt, opts, opts_log_buf, opts_log_buf_size);
+ prog_name[0] = '\0';
+ ret = bpf_load_program_xattr(attr, attr_log_buf, attr_log_buf_size);
}
if (ret < 0 && errno == EPERM) {
@@ -809,14 +744,14 @@ int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
rl.rlim_max = RLIM_INFINITY;
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_MEMLOCK, &rl) == 0)
- ret = libbpf_bpf_prog_load(prog_type, new_prog_name, license, insns, insns_cnt, opts, opts_log_buf, opts_log_buf_size);
+ ret = bpf_load_program_xattr(attr, attr_log_buf, attr_log_buf_size);
}
}
if (ret < 0 && errno == E2BIG) {
fprintf(stderr,
"bpf: %s. Program %s too large (%u insns), at most %d insns\n\n",
- strerror(errno), new_prog_name, insns_cnt, BPF_MAXINSNS);
+ strerror(errno), attr->name, insns_cnt, BPF_MAXINSNS);
return -1;
}
@@ -825,9 +760,9 @@ int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
// User has provided a log buffer.
if (log_buf_size) {
// If logging is not already enabled, enable it and do the syscall again.
- if (opts->log_level == 0) {
- opts->log_level = 1;
- ret = libbpf_bpf_prog_load(prog_type, new_prog_name, license, insns, insns_cnt, opts, log_buf, log_buf_size);
+ if (attr->log_level == 0) {
+ attr->log_level = 1;
+ ret = bpf_load_program_xattr(attr, log_buf, log_buf_size);
}
// Print the log message and return.
bpf_print_hints(ret, log_buf);
@@ -841,8 +776,8 @@ int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
if (tmp_log_buf)
free(tmp_log_buf);
tmp_log_buf_size = LOG_BUF_SIZE;
- if (opts->log_level == 0)
- opts->log_level = 1;
+ if (attr->log_level == 0)
+ attr->log_level = 1;
for (;;) {
tmp_log_buf = malloc(tmp_log_buf_size);
if (!tmp_log_buf) {
@@ -851,7 +786,7 @@ int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
goto return_result;
}
tmp_log_buf[0] = 0;
- ret = libbpf_bpf_prog_load(prog_type, new_prog_name, license, insns, insns_cnt, opts, tmp_log_buf, tmp_log_buf_size);
+ ret = bpf_load_program_xattr(attr, tmp_log_buf, tmp_log_buf_size);
if (ret < 0 && errno == ENOSPC) {
// Temporary buffer size is not enough. Double it and try again.
free(tmp_log_buf);
@@ -865,7 +800,7 @@ int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
// Check if we should print the log message if log_level is not 0,
// either specified by user or set due to error.
- if (opts->log_level > 0) {
+ if (attr->log_level > 0) {
// Don't print if user enabled logging and provided log buffer,
// but there is no error.
if (log_buf && ret < 0)
@@ -885,13 +820,16 @@ int bcc_prog_load(enum bpf_prog_type prog_type, const char *name,
const char *license, unsigned kern_version,
int log_level, char *log_buf, unsigned log_buf_size)
{
- struct bpf_prog_load_opts opts = {};
-
+ struct bpf_load_program_attr attr = {};
+ attr.prog_type = prog_type;
+ attr.name = name;
+ attr.insns = insns;
+ attr.license = license;
if (prog_type != BPF_PROG_TYPE_TRACING && prog_type != BPF_PROG_TYPE_EXT)
- opts.kern_version = kern_version;
- opts.log_level = log_level;
- return bcc_prog_load_xattr(prog_type, name, license, insns, &opts, prog_len, log_buf, log_buf_size, true);
+ attr.kern_version = kern_version;
+ attr.log_level = log_level;
+ return bcc_prog_load_xattr(&attr, prog_len, log_buf, log_buf_size, true);
}
int bpf_open_raw_sock(const char *name)
@@ -1388,7 +1326,7 @@ int kernel_struct_has_field(const char *struct_name, const char *field_name)
struct btf *btf;
int i, ret, btf_id;
- btf = btf__load_vmlinux_btf();
+ btf = libbpf_find_kernel_btf();
ret = libbpf_get_error(btf);
if (ret)
return -1;
@@ -1565,7 +1503,7 @@ int bpf_attach_xdp(const char *dev_name, int progfd, uint32_t flags) {
return -1;
}
- ret = bpf_xdp_attach(ifindex, progfd, flags, NULL);
+ ret = bpf_set_link_xdp_fd(ifindex, progfd, flags);
if (ret) {
libbpf_strerror(ret, err_buf, sizeof(err_buf));
fprintf(stderr, "bpf: Attaching prog to %s: %s\n", dev_name, err_buf);
diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h
index dd86f0a9..e001d740 100644
--- a/src/cc/libbpf.h
+++ b/src/cc/libbpf.h
@@ -27,25 +27,8 @@
extern "C" {
#endif
-struct bcc_create_map_attr {
- const char *name;
- enum bpf_map_type map_type;
- __u32 map_flags;
- __u32 key_size;
- __u32 value_size;
- __u32 max_entries;
- __u32 numa_node;
- __u32 btf_fd;
- __u32 btf_key_type_id;
- __u32 btf_value_type_id;
- __u32 map_ifindex;
- union {
- __u32 inner_map_fd;
- __u32 btf_vmlinux_value_type_id;
- };
-};
-
-struct bpf_prog_load_opts;
+struct bpf_create_map_attr;
+struct bpf_load_program_attr;
enum bpf_probe_attach_type {
BPF_PROBE_ENTRY,
@@ -61,7 +44,7 @@ struct bcc_perf_buffer_opts {
int bcc_create_map(enum bpf_map_type map_type, const char *name,
int key_size, int value_size, int max_entries,
int map_flags);
-int bcc_create_map_xattr(struct bcc_create_map_attr *attr, bool allow_rlimit);
+int bcc_create_map_xattr(struct bpf_create_map_attr *attr, bool allow_rlimit);
int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags);
int bpf_lookup_elem(int fd, void *key, void *value);
int bpf_delete_elem(int fd, void *key);
@@ -89,11 +72,10 @@ int bcc_prog_load(enum bpf_prog_type prog_type, const char *name,
const struct bpf_insn *insns, int prog_len,
const char *license, unsigned kern_version,
int log_level, char *log_buf, unsigned log_buf_size);
-int bcc_prog_load_xattr(enum bpf_prog_type prog_type, const char *prog_name,
- const char *license, const struct bpf_insn *insns,
- struct bpf_prog_load_opts *opts,
+int bcc_prog_load_xattr(struct bpf_load_program_attr *attr,
int prog_len, char *log_buf,
unsigned log_buf_size, bool allow_rlimit);
+
int bpf_attach_socket(int sockfd, int progfd);
/* create RAW socket. If name is not NULL/a non-empty null-terminated string,
--
2.38.1

42
SOURCES/bcc-0.25.0-Revert-tools-tcpaccept-Fix-support-for-v5.6-kernels.patch
Unescape View File

@ -0,0 +1,42 @@
From acee5d39d24b102e8ed09a242cb1c53246a1fb7f Mon Sep 17 00:00:00 2001
From: Jerome Marchand <jmarchan@redhat.com>
Date: Tue, 29 Nov 2022 15:33:49 +0100
Subject: [PATCH] Revert "tools/tcpaccept: Fix support for v5.6+ kernels"
This reverts commit 28955512d991ee3849c2a9accfc54bef9cd35f21.
It breaks tcpaccept on RHEL 8 kernel.
---
tools/tcpaccept.py | 9 ++-------
1 file changed, 2 insertions(+), 7 deletions(-)
diff --git a/tools/tcpaccept.py b/tools/tcpaccept.py
index b2ace4fa..d3e44143 100755
--- a/tools/tcpaccept.py
+++ b/tools/tcpaccept.py
@@ -116,7 +116,7 @@ int kretprobe__inet_csk_accept(struct pt_regs *ctx)
return 0;
// check this is TCP
- u16 protocol = 0;
+ u8 protocol = 0;
// workaround for reading the sk_protocol bitfield:
// Following comments add by Joe Yin:
@@ -132,12 +132,7 @@ int kretprobe__inet_csk_accept(struct pt_regs *ctx)
int gso_max_segs_offset = offsetof(struct sock, sk_gso_max_segs);
int sk_lingertime_offset = offsetof(struct sock, sk_lingertime);
-
- // Since kernel v5.6 sk_protocol is its own u16 field and gso_max_segs
- // precedes sk_lingertime.
- if (sk_lingertime_offset - gso_max_segs_offset == 2)
- protocol = newsk->sk_protocol;
- else if (sk_lingertime_offset - gso_max_segs_offset == 4)
+ if (sk_lingertime_offset - gso_max_segs_offset == 4)
// 4.10+ with little endian
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
protocol = *(u8 *)((u64)&newsk->sk_gso_max_segs - 3);
--
2.38.1

75
SOURCES/bcc-0.25.0-libbpf-Allow-kernel_struct_has_field-to-reach-field-.patch
Unescape View File

@ -0,0 +1,75 @@
From 16277e3910c9281d807fc6d3b4ce41c62d7d265e Mon Sep 17 00:00:00 2001
From: Jerome Marchand <jmarchan@redhat.com>
Date: Thu, 19 May 2022 16:37:40 +0200
Subject: [PATCH 3/3] libbpf: Allow kernel_struct_has_field to reach field in
unnamed struct or union
Some fields can belong to unnamed struct or union (e.g. rcu and
rcu_users fields of task_struct). In C, they are accessed as if their
belong directly to the parent of the unnamed struct or union but this
is not the case for BTF.
When looking for a field, kernel_struct_has_field should also look
reccursively into unnamed structs or unions. That allows code such as
the following to work as expected:
BPF.kernel_struct_has_field('task_struct', 'rcu')
Signed-off-by: Jerome Marchand <jmarchan@redhat.com>
---
src/cc/libbpf.c | 28 ++++++++++++++++++----------
1 file changed, 18 insertions(+), 10 deletions(-)
diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c
index 5f7a3f68..bdfde1f5 100644
--- a/src/cc/libbpf.c
+++ b/src/cc/libbpf.c
@@ -1319,12 +1319,27 @@ bool bpf_has_kernel_btf(void)
return true;
}
+static int find_member_by_name(struct btf *btf, const struct btf_type *btf_type, const char *field_name) {
+ const struct btf_member *btf_member = btf_members(btf_type);
+ int i;
+
+ for (i = 0; i < btf_vlen(btf_type); i++, btf_member++) {
+ const char *name = btf__name_by_offset(btf, btf_member->name_off);
+ if (!strcmp(name, field_name)) {
+ return 1;
+ } else if (name[0] == '\0') {
+ if (find_member_by_name(btf, btf__type_by_id(btf, btf_member->type), field_name))
+ return 1;
+ }
+ }
+ return 0;
+}
+
int kernel_struct_has_field(const char *struct_name, const char *field_name)
{
const struct btf_type *btf_type;
- const struct btf_member *btf_member;
struct btf *btf;
- int i, ret, btf_id;
+ int ret, btf_id;
btf = libbpf_find_kernel_btf();
ret = libbpf_get_error(btf);
@@ -1338,14 +1353,7 @@ int kernel_struct_has_field(const char *struct_name, const char *field_name)
}
btf_type = btf__type_by_id(btf, btf_id);
- btf_member = btf_members(btf_type);
- for (i = 0; i < btf_vlen(btf_type); i++, btf_member++) {
- if (!strcmp(btf__name_by_offset(btf, btf_member->name_off), field_name)) {
- ret = 1;
- goto cleanup;
- }
- }
- ret = 0;
+ ret = find_member_by_name(btf, btf_type, field_name);
cleanup:
btf__free(btf);
--
2.38.1

410
SPECS/bcc.spec
Unescape View File

@ -0,0 +1,410 @@
# luajit is not available RHEL 8
%bcond_with lua
%bcond_with llvm_static
%if %{without llvm_static}
%global with_llvm_shared 1
%endif
Name: bcc
Version: 0.25.0
Release: 2%{?dist}
Summary: BPF Compiler Collection (BCC)
License: ASL 2.0
URL: https://github.com/iovisor/bcc
Source0: %{url}/archive/v%{version}/%{name}-%{version}.tar.gz
Patch0: %{name}-%{version}-Manpages-remove-unstable-statement.patch
Patch1: %{name}-%{version}-RHEL-libbpf-version-fixes.patch
Patch2: %{name}-%{version}-libbpf-Allow-kernel_struct_has_field-to-reach-field-.patch
Patch3: %{name}-%{version}-Fix-bpf_pseudo_fd-type-conversion-error.patch
Patch4: %{name}-%{version}-Fix-clang-15-int-to-pointer-conversion-errors.patch
Patch5: %{name}-%{version}-Revert-tools-tcpaccept-Fix-support-for-v5.6-kernels.patch
Patch6: %{name}-%{version}-Fix-get_kprobe_functions.patch
# Arches will be included as upstream support is added and dependencies are
# satisfied in the respective arches
ExcludeArch: i686
BuildRequires: bison
BuildRequires: cmake >= 2.8.7
BuildRequires: flex
BuildRequires: libxml2-devel
BuildRequires: python3-devel
BuildRequires: elfutils-libelf-devel
BuildRequires: llvm-devel
BuildRequires: clang-devel
%if %{with llvm_static}
BuildRequires: llvm-static
%endif
BuildRequires: ncurses-devel
%if %{with lua}
BuildRequires: pkgconfig(luajit)
%endif
BuildRequires: libbpf-devel >= 0.5.0, libbpf-static >= 0.5.0
Requires: libbpf >= 0.5.0
Requires: tar
Recommends: kernel-devel
Recommends: %{name}-tools = %{version}-%{release}
%description
BCC is a toolkit for creating efficient kernel tracing and manipulation
programs, and includes several useful tools and examples. It makes use of
extended BPF (Berkeley Packet Filters), formally known as eBPF, a new feature
that was first added to Linux 3.15. BCC makes BPF programs easier to write,
with kernel instrumentation in C (and includes a C wrapper around LLVM), and
front-ends in Python and lua. It is suited for many tasks, including
performance analysis and network traffic control.
%package devel
Summary: Shared library for BPF Compiler Collection (BCC)
Requires: %{name}%{?_isa} = %{version}-%{release}
%description devel
The %{name}-devel package contains libraries and header files for developing
application that use BPF Compiler Collection (BCC).
%package doc
Summary: Examples for BPF Compiler Collection (BCC)
Recommends: python3-%{name} = %{version}-%{release}
%if %{with lua}
Recommends: %{name}-lua = %{version}-%{release}
%endif
BuildArch: noarch
%description doc
Examples for BPF Compiler Collection (BCC)
%package -n python3-%{name}
Summary: Python3 bindings for BPF Compiler Collection (BCC)
Requires: %{name}%{?_isa} = %{version}-%{release}
%{?python_provide:%python_provide python3-%{name}}
%description -n python3-%{name}
Python3 bindings for BPF Compiler Collection (BCC)
%if %{with lua}
%package lua
Summary: Standalone tool to run BCC tracers written in Lua
Requires: %{name}%{?_isa} = %{version}-%{release}
%description lua
Standalone tool to run BCC tracers written in Lua
%endif
%package tools
Summary: Command line tools for BPF Compiler Collection (BCC)
Requires: bcc = %{version}-%{release}
Requires: python3-%{name} = %{version}-%{release}
Requires: python3-netaddr
%description tools
Command line tools for BPF Compiler Collection (BCC)
%prep
%autosetup -p1
%build
%cmake . \
-DCMAKE_BUILD_TYPE=RelWithDebInfo \
-DREVISION_LAST=%{version} -DREVISION=%{version} -DPYTHON_CMD=python3 \
-DCMAKE_USE_LIBBPF_PACKAGE:BOOL=TRUE \
%{?with_llvm_shared:-DENABLE_LLVM_SHARED=1}
%make_build
%install
%make_install
# Fix python shebangs
# This messes the timestamp and rpmdiff complains about it
# Let's set the all thing according to a reference file
touch -r %{buildroot}%{_datadir}/%{name}/examples/hello_world.py %{_tmppath}/timestamp
find %{buildroot}%{_datadir}/%{name}/{tools,examples} -type f -exec \
sed -i -e '1s=^#!/usr/bin/python\([0-9.]\+\)\?$=#!%{__python3}=' \
-e '1s=^#!/usr/bin/env python\([0-9.]\+\)\?$=#!%{__python3}=' \
-e '1s=^#!/usr/bin/env bcc-lua$=#!/usr/bin/bcc-lua=' {} \;
for i in `find %{buildroot}%{_datadir}/%{name}/examples/` ; do
touch -h -r %{_tmppath}/timestamp $i
done
# Move man pages to the right location
mkdir -p %{buildroot}%{_mandir}
mv %{buildroot}%{_datadir}/%{name}/man/* %{buildroot}%{_mandir}/
# Avoid conflict with other manpages
# https://bugzilla.redhat.com/show_bug.cgi?id=1517408
for i in `find %{buildroot}%{_mandir} -name "*.gz"`; do
tname=$(basename $i)
rename $tname %{name}-$tname $i
done
# Fix the symlink too
for i in `find %{buildroot}%{_mandir} -lname \*.gz` ; do
target=`readlink $i`;
ln -sf bcc-$target $i;
done
# We cannot run the test suit since it requires root and it makes changes to
# the machine (e.g, IP address)
#%check
%ldconfig_scriptlets
%files
%doc README.md
%license LICENSE.txt
%{_libdir}/lib%{name}.so.*
%{_libdir}/libbcc_bpf.so.*
%files devel
%exclude %{_libdir}/lib%{name}*.a
%exclude %{_libdir}/lib%{name}*.la
%{_libdir}/lib%{name}.so
%{_libdir}/libbcc_bpf.so
%{_libdir}/pkgconfig/lib%{name}.pc
%{_includedir}/%{name}/
%files -n python3-%{name}
%{python3_sitelib}/%{name}*
%files doc
# % dir % {_docdir}/% {name}
%doc %{_datadir}/%{name}/examples/
%if %{without lua}
%exclude %{_datadir}/%{name}/examples/lua
%endif
%files tools
%dir %{_datadir}/%{name}
%dir %{_datadir}/%{name}/tools
%dir %{_datadir}/%{name}/introspection
%{_datadir}/%{name}/tools/*
%{_datadir}/%{name}/introspection/*
%exclude %{_datadir}/%{name}/tools/old/
# inject relies on BPF_KPROBE_OVERRIDE which is not set on RHEL 8
%exclude %{_datadir}/%{name}/tools/inject
%exclude %{_datadir}/%{name}/tools/doc/inject_example.txt
%exclude %{_mandir}/man8/bcc-inject.8.gz
# Neither btrfs nor zfs are available on RHEL8
%exclude %{_datadir}/%{name}/tools/btrfs*
%exclude %{_datadir}/%{name}/tools/doc/btrfs*
%exclude %{_mandir}/man8/bcc-btrfs*
%exclude %{_datadir}/%{name}/tools/zfs*
%exclude %{_datadir}/%{name}/tools/doc/zfs*
%exclude %{_mandir}/man8/bcc-zfs*
# criticalstat relies on CONFIG_PREEMPTIRQ_EVENTS which is disabled on RHEL 8
%exclude %{_datadir}/%{name}/tools/criticalstat
%exclude %{_datadir}/%{name}/tools/doc/criticalstat_example.txt
%exclude %{_mandir}/man8/bcc-criticalstat.8.gz
# compactsnoop is only supported on x86_64
%ifnarch x86_64
%exclude %{_datadir}/%{name}/tools/compactsnoop
%exclude %{_datadir}/%{name}/tools/doc/compactsnoop_example.txt
%exclude %{_mandir}/man8/bcc-compactsnoop.8.gz
%endif
%{_mandir}/man8/*
%if %{with lua}
%files lua
%{_bindir}/bcc-lua
%endif
%changelog
* Tue Jan 10 2023 Jerome Marchand <jmarchan@redhat.com> - 0.25.0-2
- Fix tcpdrop tool
* Wed Nov 30 2022 Jerome Marchand <jmarchan@redhat.com> - 0.25.0-1
- Rebase to bcc-0.25.0
- Rebuild on LLVM 15
* Thu Jun 23 2022 Jerome Marchand <jmarchan@redhat.com> - 0.24.0-2
- Rebuild on libbpf 0.5.0
* Thu Jun 09 2022 Jerome Marchand <jmarchan@redhat.com> - 0.24.0-1
- Rebase to bcc-0.24.0
- Rebuild on LLVM 14
* Mon Dec 06 2021 Jerome Marchand <jmarchan@redhat.com> - 0.19.0-6
- Add excplicit requirement in bcc-tools for rpmdiff
* Tue Nov 23 2021 Jerome Marchand <jmarchan@redhat.com> - 0.19.0-5
- Handle the renaming of task_struct_>state field
- Rebuild for LLVM 13
* Fri Jul 02 2021 Jerome Marchand <jmarchan@redhat.com> - 0.19.0-4
- Build bcc from standard sources
- Don't require bcc-tools by default
* Wed Jun 09 2021 Jerome Marchand <jmarchan@redhat.com> - 0.19.0-3
- Rebuild on LLVM 12
* Fri Apr 30 2021 Jerome Marchand <jmarchan@redhat.com> - 0.19.0-2
- Fix BPF src_file.
* Tue Apr 27 2021 Jerome Marchand <jmarchan@redhat.com> - 0.19.0-1
- Rebased to version 0.19.0
- Remove hard dependency on kernel-devel
* Fri Jan 22 2021 Jerome Marchand <jmarchan@redhat.com> - 0.16.0-2
- Build with libbpf package
- spec file cleanups
* Mon Oct 26 2020 Jerome Marchand <jmarchan@redhat.com> - 0.16.0-1
- Rebase on bcc-0.16.0
- Fix IPv6 ports
* Wed Sep 02 2020 Jerome Marchand <jmarchan@redhat.com> - 0.14.0-4
- Fix KFUNC_PROBE return value
- Forbid trampolines on unsupported arches
* Tue Jul 21 2020 Jerome Marchand <jmarchan@redhat.com> - 0.14.0-3
- Add KBUILD_MODNAME flag to default cflags
* Thu Jun 11 2020 Jerome Marchand <jmarchan@redhat.com> - 0.14.0-2
- Remove criticalstat manpage
- Remove compactsnoop on non x86_64
- Suggest to use --binary in deadlock
- Remove non-existent argument from tcpconnect man page
- Suggest to install the proper kernel-devel version
- Fix dbstat and dbslower
* Wed Apr 22 2020 Jerome Marchand <jmarchan@redhat.com> - 0.14.0-1
- Rebase on bcc-0.14.0
* Wed Dec 04 2019 Jerome Marchand <jmarchan@redhat.com> - 0.11.0-2
- Add -c option ton the synopsis of tcpretrans manpage
* Tue Nov 26 2019 Jerome Marchand <jmarchan@redhat.com> - 0.11.0-1
- Rebase to bcc-0.11.0
- Reinstate the unstable comment patch that has been removed by mistake
* Thu Oct 17 2019 Jerome Marchand <jmarchan@redhat.com> - 0.10.0-1
- Rebase to bcc-0.10.0
- Drop criticalstat
- Fix regression on vfscount and runqslower
- Rebuild on LLVM 9
* Tue Aug 06 2019 Jerome Marchand <jmarchan@redhat.com> - 0.8.0-4
- remove unstable statement from the man pages
* Wed Jul 03 2019 Jerome Marchand <jmarchan@redhat.com> - 0.8.0-3
- fix b.support_raw_tracepoint
- fix runqslower warning
* Wed May 15 2019 Jerome Marchand <jmarchan@redhat.com> - 0.8.0-2
- Rebuild for llvm 8
* Thu Apr 11 2019 Jerome Marchand <jmarchan@redhat.com> - 0.8.0-1
- Rebase on bcc-8.0.0
- Replace the temporary s390x workaround by a proper fix
- Remove the doc of excluded tool from the package
- Fix print_log2_hist
- Fix yet a few other python3 bytes vs strings issues
* Mon Mar 25 2019 Jerome Marchand <jmarchan@redhat.com> - 0.7.0-6
- Add CI gating
* Thu Dec 13 2018 Jerome Marchand <jmarchan@redhat.com> - 0.7.0-5
- Fix biolatency -D
- Fix biotop manpage
- Rebuild for LLVM 7.0.1 (from Tom Stellard)
* Mon Dec 10 2018 Jerome Marchand <jmarchan@redhat.com> - 0.7.0-4
- Fix bio* tools
* Mon Nov 05 2018 Jerome Marchand <jmarchan@redhat.com> - 0.7.0-3
- Fix multiple bytes/string encoding issues
- Fix misc covscan warning
* Mon Oct 15 2018 Tom Stellard <tstellar@redhat.com> - 0.7.0-2
- Drop explicit dependency on clang-libs
* Fri Oct 12 2018 Jerome Marchand <jmarchan@redhat.com> - 0.7.0-1
- Rebase on bcc-7.0.0
- Remove useless tools (zfs*, btrfs* and inject)
* Thu Sep 20 2018 Jerome Marchand <jmarchan@redhat.com> - 0.6.1-1
- Rebase on bcc-0.6.1
* Thu Sep 20 2018 Jerome Marchand <jmarchan@redhat.com> - 0.6.0-6
- llcstat: print a nicer error message on virtual machine
- Add NSS support to sslsniff
- Fixes miscellaneous error uncovered by covscan
* Wed Aug 08 2018 Tom Stellard <tstellar@redhat.com> - 0.6.0-5
- Use llvm-toolset-6.0 prefix for clang-libs dependency
* Fri Aug 03 2018 Tom Stellard <tstellar@redhat.com> - 0.6.0-4
- Rebuld for llvm-toolset-6.0
* Wed Jul 18 2018 Jerome Marchand <jmarchan@redhat.com> - 0.6.0-3
- Disable lua on all arches
* Tue Jun 26 2018 Jerome Marchand <jmarchan@redhat.com> - 0.6.0-2
- Add clang-libs requirement
- Fix manpages symlinks
* Tue Jun 19 2018 Jerome Marchand <jmarchan@redhat.com> - 0.6.0-1
- Rebase on bcc-0.6.0
* Thu May 24 2018 Jerome Marchand <jmarchan@redhat.com> - 0.5.0-5
- Enables build on ppc64(le) and s390x arches
* Thu Apr 05 2018 Rafael Santos <rdossant@redhat.com> - 0.5.0-4
- Resolves #1555627 - fix compilation error with latest llvm/clang
* Wed Feb 07 2018 Fedora Release Engineering <releng@fedoraproject.org> - 0.5.0-3
- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild
* Fri Feb 02 2018 Igor Gnatenko <ignatenkobrain@fedoraproject.org> - 0.5.0-2
- Switch to %%ldconfig_scriptlets
* Wed Jan 03 2018 Rafael Santos <rdossant@redhat.com> - 0.5.0-1
- Rebase to new released version
* Thu Nov 16 2017 Rafael Santos <rdossant@redhat.com> - 0.4.0-4
- Resolves #1517408 - avoid conflict with other manpages
* Thu Nov 02 2017 Rafael Santos <rdossant@redhat.com> - 0.4.0-3
- Use weak deps to not require lua subpkg on ppc64(le)
* Wed Nov 01 2017 Igor Gnatenko <ignatenkobrain@fedoraproject.org> - 0.4.0-2
- Rebuild for LLVM5
* Wed Nov 01 2017 Rafael Fonseca <rdossant@redhat.com> - 0.4.0-1
- Resolves #1460482 - rebase to new release
- Resolves #1505506 - add support for LLVM 5.0
- Resolves #1460482 - BPF module compilation issue
- Partially address #1479990 - location of man pages
- Enable ppc64(le) support without lua
- Soname versioning for libbpf by ignatenkobrain
* Wed Aug 02 2017 Fedora Release Engineering <releng@fedoraproject.org> - 0.3.0-4
- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild
* Wed Jul 26 2017 Fedora Release Engineering <releng@fedoraproject.org> - 0.3.0-3
- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild
* Thu Mar 30 2017 Igor Gnatenko <ignatenko@redhat.com> - 0.3.0-2
- Rebuild for LLVM4
- Trivial fixes in spec
* Fri Mar 10 2017 Rafael Fonseca <rdossant@redhat.com> - 0.3.0-1
- Rebase to new release.
* Fri Feb 10 2017 Fedora Release Engineering <releng@fedoraproject.org> - 0.2.0-3
- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild
* Tue Jan 10 2017 Rafael Fonseca <rdossant@redhat.com> - 0.2.0-2
- Fix typo
* Tue Nov 29 2016 Rafael Fonseca <rdossant@redhat.com> - 0.2.0-1
- Initial import
Write Preview
Loading…
Cancel
Save