Deploying to gh-pages from @ eunomia-bpf/bpf-developer-tutorial@4671af2739 🚀

37-uprobe-rust/args/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

37-uprobe-rust/args/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "helloworld"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

37-uprobe-rust/args/src/main.rs

@@ -0,0 +1,23 @@
+use std::env;
+
+pub fn hello(i: i32, len: usize) -> i32 {
+    println!("Hello, world! {} in {}", i, len);
+    i + len as i32
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+
+    // Skip the first argument, which is the path to the binary, and iterate over the rest
+    for arg in args.iter().skip(1) {
+        match arg.parse::<i32>() {
+            Ok(i) => {
+                let ret = hello(i, args.len());
+                println!("return value: {}", ret);
+            }
+            Err(_) => {
+                eprintln!("Error: Argument '{}' is not a valid integer", arg);
+            }
+        }
+    }
+}

37-uprobe-rust/helloworld/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

37-uprobe-rust/helloworld/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "helloworld"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

37-uprobe-rust/helloworld/src/main.rs

@@ -0,0 +1,8 @@
+pub fn hello() -> i32 {
+    println!("Hello, world!");
+    0
+}
+
+fn main() {
+    hello();
+}

38-btf-uprobe/.gitignore

@@ -0,0 +1,4 @@
+.output
+uprobe
+merge-btf
+*.btf

38-btf-uprobe/Makefile

@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
+OUTPUT := .output
+CLANG ?= clang
+LIBBPF_SRC := $(abspath ../third_party/libbpf/src)
+BPFTOOL_SRC := $(abspath ../third_party/bpftool/src)
+LIBBPF_OBJ := $(abspath $(OUTPUT)/libbpf.a)
+BPFTOOL_OUTPUT ?= $(abspath $(OUTPUT)/bpftool)
+BPFTOOL ?= $(BPFTOOL_OUTPUT)/bootstrap/bpftool
+ARCH ?= $(shell uname -m | sed 's/x86_64/x86/' \
+			 | sed 's/arm.*/arm/' \
+			 | sed 's/aarch64/arm64/' \
+			 | sed 's/ppc64le/powerpc/' \
+			 | sed 's/mips.*/mips/' \
+			 | sed 's/riscv64/riscv/' \
+			 | sed 's/loongarch64/loongarch/')
+VMLINUX := ../third_party/vmlinux/$(ARCH)/vmlinux.h
+# Use our own libbpf API headers and Linux UAPI headers distributed with
+# libbpf to avoid dependency on system-wide headers, which could be missing or
+# outdated
+INCLUDES := -I$(OUTPUT) -I../third_party/libbpf/include/ -I../third_party/libbpf/include/uapi -I$(dir $(VMLINUX))
+CFLAGS := -g -Wall
+ALL_LDFLAGS := $(LDFLAGS) $(EXTRA_LDFLAGS)
+
+APPS = uprobe # minimal minimal_legacy  kprobe fentry usdt sockfilter tc ksyscall
+
+CARGO ?= $(shell which cargo)
+ifeq ($(strip $(CARGO)),)
+BZS_APPS :=
+else
+BZS_APPS := # profile
+APPS += $(BZS_APPS)
+# Required by libblazesym
+ALL_LDFLAGS += -lrt -ldl -lpthread -lm
+endif
+
+# Get Clang's default includes on this system. We'll explicitly add these dirs
+# to the includes list when compiling with `-target bpf` because otherwise some
+# architecture-specific dirs will be "missing" on some architectures/distros -
+# headers such as asm/types.h, asm/byteorder.h, asm/socket.h, asm/sockios.h,
+# sys/cdefs.h etc. might be missing.
+#
+# Use '-idirafter': Don't interfere with include mechanics except where the
+# build would have failed anyways.
+CLANG_BPF_SYS_INCLUDES ?= $(shell $(CLANG) -v -E - </dev/null 2>&1 \
+	| sed -n '/<...> search starts here:/,/End of search list./{ s| \(/.*\)|-idirafter \1|p }')
+
+ifeq ($(V),1)
+	Q =
+	msg =
+else
+	Q = @
+	msg = @printf '  %-8s %s%s\n'					\
+		      "$(1)"						\
+		      "$(patsubst $(abspath $(OUTPUT))/%,%,$(2))"	\
+		      "$(if $(3), $(3))";
+	MAKEFLAGS += --no-print-directory
+endif
+
+define allow-override
+  $(if $(or $(findstring environment,$(origin $(1))),\
+            $(findstring command line,$(origin $(1)))),,\
+    $(eval $(1) = $(2)))
+endef
+
+$(call allow-override,CC,$(CROSS_COMPILE)cc)
+$(call allow-override,LD,$(CROSS_COMPILE)ld)
+
+.PHONY: all
+all: $(APPS) merge-btf
+
+.PHONY: clean
+clean:
+	$(call msg,CLEAN)
+	$(Q)rm -rf $(OUTPUT) $(APPS)
+
+$(OUTPUT) $(OUTPUT)/libbpf $(BPFTOOL_OUTPUT):
+	$(call msg,MKDIR,$@)
+	$(Q)mkdir -p $@
+
+# Build libbpf
+$(LIBBPF_OBJ): $(wildcard $(LIBBPF_SRC)/*.[ch] $(LIBBPF_SRC)/Makefile) | $(OUTPUT)/libbpf
+	$(call msg,LIB,$@)
+	$(Q)$(MAKE) -C $(LIBBPF_SRC) BUILD_STATIC_ONLY=1		      \
+		    OBJDIR=$(dir $@)/libbpf DESTDIR=$(dir $@)		      \
+		    INCLUDEDIR= LIBDIR= UAPIDIR=			      \
+		    install
+
+# Build bpftool
+$(BPFTOOL): | $(BPFTOOL_OUTPUT)
+	$(call msg,BPFTOOL,$@)
+	$(Q)$(MAKE) ARCH= CROSS_COMPILE= OUTPUT=$(BPFTOOL_OUTPUT)/ -C $(BPFTOOL_SRC) bootstrap
+
+
+$(LIBBLAZESYM_SRC)/target/release/libblazesym.a::
+	$(Q)cd $(LIBBLAZESYM_SRC) && $(CARGO) build --features=cheader,dont-generate-test-files --release
+
+$(LIBBLAZESYM_OBJ): $(LIBBLAZESYM_SRC)/target/release/libblazesym.a | $(OUTPUT)
+	$(call msg,LIB, $@)
+	$(Q)cp $(LIBBLAZESYM_SRC)/target/release/libblazesym.a $@
+
+$(LIBBLAZESYM_HEADER): $(LIBBLAZESYM_SRC)/target/release/libblazesym.a | $(OUTPUT)
+	$(call msg,LIB,$@)
+	$(Q)cp $(LIBBLAZESYM_SRC)/target/release/blazesym.h $@
+
+# Build BPF code
+$(OUTPUT)/%.bpf.o: %.bpf.c $(LIBBPF_OBJ) $(wildcard %.h) $(VMLINUX) | $(OUTPUT) $(BPFTOOL)
+	$(call msg,BPF,$@)
+	$(Q)$(CLANG) -g -O2 -target bpf -D__TARGET_ARCH_$(ARCH)		      \
+		     $(INCLUDES) $(CLANG_BPF_SYS_INCLUDES)		      \
+		     -c $(filter %.c,$^) -o $(patsubst %.bpf.o,%.tmp.bpf.o,$@)
+	$(Q)$(BPFTOOL) gen object $@ $(patsubst %.bpf.o,%.tmp.bpf.o,$@)
+
+# Generate BPF skeletons
+$(OUTPUT)/%.skel.h: $(OUTPUT)/%.bpf.o | $(OUTPUT) $(BPFTOOL)
+	$(call msg,GEN-SKEL,$@)
+	$(Q)$(BPFTOOL) gen skeleton $< > $@
+
+# Build user-space code
+$(patsubst %,$(OUTPUT)/%.o,$(APPS)): %.o: %.skel.h
+
+$(OUTPUT)/%.o: %.c $(wildcard %.h) | $(OUTPUT)
+	$(call msg,CC,$@)
+	$(Q)$(CC) $(CFLAGS) $(INCLUDES) -c $(filter %.c,$^) -o $@
+
+$(patsubst %,$(OUTPUT)/%.o,$(BZS_APPS)): $(LIBBLAZESYM_HEADER)
+
+$(BZS_APPS): $(LIBBLAZESYM_OBJ)
+
+# Build application binary
+$(APPS): %: $(OUTPUT)/%.o $(LIBBPF_OBJ) | $(OUTPUT)
+	$(call msg,BINARY,$@)
+	$(Q)$(CC) $(CFLAGS) $^ $(ALL_LDFLAGS) -lelf -lz -o $@
+
+merge-btf: merge-btf.c
+	$(call msg,CC,$@)
+	$(Q)$(CC) $(CFLAGS) merge-btf.c  $(LIBBPF_OBJ) $(INCLUDES) $(ALL_LDFLAGS) -lelf -lz -o $@
+
+# delete failed targets
+.DELETE_ON_ERROR:
+
+# keep intermediate (.skel.h, .bpf.o, etc) targets
+.SECONDARY:

38-btf-uprobe/examples/.gitignore

@@ -0,0 +1,4 @@
+*.o
+*.btf
+btf-base
+btf-base-new

38-btf-uprobe/examples/Makefile

@@ -0,0 +1,35 @@
+# BPF compiler
+BPF_CC = clang
+# BPF C flags
+BPF_CFLAGS = -O2 -target bpf -c -g
+# BPF source files
+BPF_SRCS = $(wildcard *.bpf.c)
+# BPF object files
+BPF_OBJS = $(BPF_SRCS:.c=.o)
+
+all: $(BPF_OBJS) base.btf btf-base btf-base-new base-new.btf
+
+%.bpf.o: %.bpf.c
+	$(BPF_CC) $(BPF_CFLAGS) $< -o $@
+
+btf-base.o: btf-base.c
+	clang -g -c btf-base.c -o btf-base.o
+
+btf-base-new.o: btf-base-new.c
+	clang -g -c btf-base-new.c -o btf-base-new.o
+
+base.btf: btf-base.o
+	pahole --btf_encode_detached base.btf btf-base.o
+
+base-new.btf: btf-base-new.o
+	pahole --btf_encode_detached base-new.btf btf-base-new.o
+
+btf-base: btf-base.o
+	clang -g btf-base.o -o btf-base
+
+btf-base-new: btf-base-new.o
+	clang -g btf-base-new.o -o btf-base-new
+	
+
+clean:
+	rm -f *.o *.btf btf-base btf-base-new

38-btf-uprobe/examples/btf-base-new.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+struct data {
+        int a;
+        int b;
+        int c;
+        int d;
+};
+
+int add_test(struct data *d) {
+    return d->a + d->c;
+}
+
+int main(int argc, char **argv) {
+    struct data d = {1, 2, 3, 4};
+    printf("add_test(&d) = %d\n", add_test(&d));
+    return 0;
+}
+

38-btf-uprobe/examples/btf-base.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+// use a different struct
+struct data {
+        int a;
+        int c;
+        int d;
+};
+
+int add_test(struct data *d) {
+    return d->a + d->c;
+}
+
+int main(int argc, char **argv) {
+    struct data d = {1, 3, 4};
+    printf("add_test(&d) = %d\n", add_test(&d));
+    return 0;
+}
+

38-btf-uprobe/examples/btf-relo.bpf.c

@@ -0,0 +1,19 @@
+#ifndef BPF_NO_PRESERVE_ACCESS_INDEX
+#pragma clang attribute push (__attribute__((preserve_access_index)), apply_to = record)
+#endif
+
+struct data {
+        int a;
+        int c;
+        int d;
+};
+
+#ifndef BPF_NO_PRESERVE_ACCESS_INDEX
+#pragma clang attribute pop
+#endif
+
+
+int add_test(struct data *d) {
+    return d->a + d->c;
+}
+

38-btf-uprobe/merge-btf.c

@@ -0,0 +1,63 @@
+#include <bpf/libbpf.h>
+#include <bpf/bpf.h>
+#include <bpf/btf.h>
+#include <errno.h>
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+    char *btf_base_path = argv[1];
+    char *btf_src_path = argv[2];
+    char *btf_dst_path = argv[3];
+    struct btf *btf_src, *btf_base;
+    int err;
+    unsigned int size;
+    const void* btf_data;
+    FILE *fp;
+
+
+    if (argc != 4)
+    {
+        fprintf(stderr, "Usage: %s <btf_base> <btf_src> <btf_dst>\n", argv[0]);
+        fprintf(stderr, "Used for merge btf info");
+        return 1;
+    }
+
+    btf_base = btf__parse(btf_base_path, NULL);
+    if (!btf_base)
+    {
+        fprintf(stderr, "Failed to parse BTF object '%s': %s\n", btf_base_path, strerror(errno));
+        return 1;
+    }
+
+    btf_src = btf__parse(btf_src_path, NULL);
+    if (!btf_src)
+    {
+        fprintf(stderr, "Failed to parse BTF object '%s': %s\n", btf_src_path, strerror(errno));
+        return 1;
+    }
+
+    err = btf__add_btf(btf_base, btf_src);
+    if (err < 0)
+    {
+        fprintf(stderr, "Failed to add BTF object '%s': %s\n", btf_src_path, strerror(errno));
+        return 1;
+    }
+
+    btf_data = btf__raw_data(btf_base, &size);
+    if (!btf_data)
+    {
+        fprintf(stderr, "Failed to get raw data of BTF object '%s': %s\n", btf_base_path, strerror(errno));
+        return 1;
+    }
+    fp = fopen(btf_dst_path, "w");
+    if (!fp)
+    {
+        fprintf(stderr, "Failed to open BTF object '%s': %s\n", btf_dst_path, strerror(errno));
+        return 1;
+    }
+    fwrite(btf_data, size, 1, fp);
+    fclose(fp);
+
+    return 0;
+}

38-btf-uprobe/uprobe.bpf.c

@@ -0,0 +1,32 @@
+#define BPF_NO_GLOBAL_DATA
+// #define BPF_NO_PRESERVE_ACCESS_INDEX
+#include <vmlinux.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+#ifndef BPF_NO_PRESERVE_ACCESS_INDEX
+#pragma clang attribute push (__attribute__((preserve_access_index)), apply_to = record)
+#endif
+
+struct data {
+        int a;
+        int c;
+        int d;
+};
+
+#ifndef BPF_NO_PRESERVE_ACCESS_INDEX
+#pragma clang attribute pop
+#endif
+
+
+SEC("uprobe/examples/btf-base:add_test")
+int BPF_UPROBE(add_test, struct data *d)
+{
+	int a = 0, c = 0;
+	bpf_probe_read_user(&a, sizeof(a), &d->a);
+	bpf_probe_read_user(&c, sizeof(c), &d->c);
+	bpf_printk("add_test(&d) %d + %d = %d\n", a, c,  a + c);
+	return a + c;
+}
+
+char LICENSE[] SEC("license") = "Dual BSD/GPL";

38-btf-uprobe/uprobe.c

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
+/* Copyright (c) 2020 Facebook */
+#include <signal.h>
+#include <stdio.h>
+#include <time.h>
+#include <stdint.h>
+#include <sys/resource.h>
+#include <bpf/libbpf.h>
+#include <bpf/bpf.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include "uprobe.skel.h"
+
+#define warn(...) fprintf(stderr, __VA_ARGS__)
+
+static int libbpf_print_fn(enum libbpf_print_level level, const char *format,
+			   va_list args)
+{
+	return vfprintf(stderr, format, args);
+}
+
+static volatile bool exiting = false;
+
+static void sig_handler(int sig)
+{
+	exiting = true;
+}
+
+int main(int argc, char **argv)
+{
+	struct uprobe_bpf *skel;
+	int err;
+	LIBBPF_OPTS(bpf_object_open_opts , opts,
+	);
+	LIBBPF_OPTS(bpf_uprobe_opts, uprobe_opts);
+	if (argc != 3 && argc != 2) {
+		fprintf(stderr, "Usage: %s <example-name> [<external-btf>]\n", argv[0]);
+		return 1;
+	}
+	if (argc == 3)
+		opts.btf_custom_path = argv[2];
+
+	/* Set up libbpf errors and debug info callback */
+	libbpf_set_print(libbpf_print_fn);
+
+	/* Cleaner handling of Ctrl-C */
+	signal(SIGINT, sig_handler);
+	signal(SIGTERM, sig_handler);
+
+	/* Load and verify BPF application */
+	skel = uprobe_bpf__open_opts(&opts);
+	if (!skel) {
+		fprintf(stderr, "Failed to open and load BPF skeleton\n");
+		return 1;
+	}
+
+	/* Load & verify BPF programs */
+	err = uprobe_bpf__load(skel);
+	if (err) {
+		fprintf(stderr, "Failed to load and verify BPF skeleton\n");
+		goto cleanup;
+	}
+
+	uprobe_opts.func_name = "add_test";
+	skel->links.add_test = bpf_program__attach_uprobe_opts(
+		skel->progs.add_test, -1 /* self pid */, argv[1] /* binary path */,
+		0 /* offset for function */, &uprobe_opts /* opts */);
+	if (!skel->links.add_test) {
+		err = -errno;
+		fprintf(stderr, "Failed to attach uprobe: %d\n", err);
+		goto cleanup;
+	}
+	printf("Successfully started! Press Ctrl+C to stop.\n");
+	fflush(stdout);
+	while (!exiting) {
+		sleep(1);
+	}
+cleanup:
+	/* Clean up */
+	uprobe_bpf__destroy(skel);
+
+	return err < 0 ? -err : 0;
+}