bpftune: support a "no BTF" mode of operation

.gitignore

@@ -3,5 +3,6 @@
 *.8
 *.skel.h
 *.skel.legacy.h
+*.skel.nobtf.h
 *.swp
 *.plist

include/bpftune/bpftune.bpf.h

@@ -18,6 +18,20 @@
  */
 
 #define __KERNEL__
+
+/* No BTF means we cannot include implicit CO-RE relocations from vmlinux.h.
+ * Also implies legacy mode since no fentry etc.
+ */
+#ifdef BPFTUNE_NOBTF
+#define BPF_NO_PRESERVE_ACCESS_INDEX
+#define BPFTUNE_PRESERVE_ACCESS_INDEX(obj, field)	\
+	(obj + __builtin_offsetof(typeof(*obj), field))
+#define BPFTUNE_LEGACY
+#else
+#define BPFTUNE_PRESERVE_ACCESS_INDEX(obj, field)	\
+	__builtin_preserve_access_index(&obj->field)
+#endif
+
 #if defined(__TARGET_ARCH_x86)
 #include <bpftune/vmlinux_x86_64.h>
 #elif defined(__TARGET_ARCH_arm64)
@@ -46,6 +60,13 @@ extern __u32 LINUX_KERNEL_VERSION __kconfig;
 })
 #endif
 
+/* No BTF -> no CO-RE support */
+#ifdef BPFTUNE_NOBTF
+#define BPFTUNE_CORE_READ	BPF_PROBE_READ
+#else
+#define BPFTUNE_CORE_READ	BPF_CORE_READ
+#endif
+
 /* provide BPF_KPROBE/BPF_KRETPROBE to simplify legacy support */
 
 #ifndef BPF_KPROBE
@@ -264,8 +285,10 @@ static __always_inline int __strncmp(char *s1, char *s2, size_t n)
 
 static __always_inline long get_netns_cookie(struct net *net)
 {
+#ifndef BPFTUNE_NOBTF
 	if (bpf_core_field_exists(net->net_cookie))
-		return BPF_CORE_READ(net, net_cookie);
+		return BPFTUNE_CORE_READ(net, net_cookie);
+#endif
 	if (net == &init_net || net == (void *)bpftune_init_net)
 		return 0;
 	/* not global ns, no cookie support. */
@@ -331,7 +354,7 @@ static __always_inline long send_sk_sysctl_event(struct sock *sk,
                                               long *old, long *new,
                                               struct bpftune_event *event)
 {
-	struct net *net = BPF_CORE_READ(sk, sk_net.net);
+	struct net *net = BPFTUNE_CORE_READ(sk, sk_net.net);
 
 	return send_net_sysctl_event(net, scenario_id, event_id,
 				     old, new, event);

include/bpftune/bpftune.h

@@ -150,6 +150,13 @@ struct bpftuner_strategy {
 				 * strategy; if NULL, all */
 };
 
+enum bpftune_support_level {
+	BPFTUNE_SUPPORT_NONE,
+	BPFTUNE_SUPPORT_NOBTF,
+	BPFTUNE_SUPPORT_LEGACY,
+	BPFTUNE_SUPPORT_NORMAL
+};
+
 struct bpftuner {
 	unsigned int id;
 	enum bpftune_state state;
@@ -158,6 +165,7 @@ struct bpftuner {
 	void *handle;
 	const char *name;
 	struct bpf_object_skeleton *skeleton;
+	enum bpftune_support_level bpf_support;
 	bool bpf_legacy;
 	void *skel;
 	void *obj;

include/bpftune/libbpftune.h

@@ -138,139 +138,135 @@ void bpftuner_tunables_fini(struct bpftuner *tuner);
 
 /* need a macro in order to generate code for skeleton-specific struct */
 
-#define bpftuner_bpf_open(tuner_name, tuner) ({				     \
-	int __err = 0;							     \
+#define __bpftuner_bpf_open(tuner_name, tuner, suffix)			     \
 	do {								     \
-		struct tuner_name##_tuner_bpf *__skel;                       \
-		struct tuner_name##_tuner_bpf_legacy *__lskel;		     \
-									     \
-                __err = bpftune_cap_add();				     \
-		if (__err) break;					     \
-                tuner->name = #tuner_name;                                   \
-		tuner->bpf_legacy = bpftuner_bpf_legacy();		     \
-                if (!tuner->bpf_legacy) {				     \
-			tuner->skel = __skel = tuner_name##_tuner_bpf__open();\
-			__err = libbpf_get_error(tuner->skel);		     \
-			if (__err) break;				     \
-			tuner->skeleton = __skel->skeleton;		     \
-			__skel->bss->debug = bpftune_log_level() >= LOG_DEBUG;\
-			__skel->bss->bpftune_pid = getpid();		     \
-			__skel->bss->bpftune_learning_rate = bpftune_learning_rate;\
-			tuner->obj = __skel->obj;			     \
-			tuner->ring_buffer_map = __skel->maps.ring_buffer_map;\
-			tuner->netns_map = __skel->maps.netns_map;	     \
-		} else {						     \
-			tuner->skel = __lskel = tuner_name##_tuner_bpf_legacy__open();\
-			__err = libbpf_get_error(tuner->skel);		     \
-			if (__err) break;				     \
-			tuner->skeleton = __lskel->skeleton;		     \
-			__lskel->bss->debug = bpftune_log_level() >= LOG_DEBUG;\
-			__lskel->bss->bpftune_learning_rate = bpftune_learning_rate;\
-			__lskel->bss->bpftune_pid = getpid();		     \
-			tuner->obj = __lskel->obj;			     \
-			tuner->ring_buffer_map = __lskel->maps.ring_buffer_map;\
-			tuner->netns_map = __lskel->maps.netns_map;	     \
+		struct tuner_name##_tuner_##suffix *__skel;		     \
+		tuner->skel = __skel = tuner_name##_tuner_##suffix##__open();\
+		tuner->skeleton = __skel->skeleton;			     \
+		__skel->bss->debug = bpftune_log_level() >= LOG_DEBUG;	     \
+		__skel->bss->bpftune_pid = getpid();			     \
+		__skel->bss->bpftune_learning_rate = bpftune_learning_rate;  \
+		__skel->bss->tuner_id = bpftune_tuner_num();		     \
+		tuner->obj = __skel->obj;				     \
+		tuner->ring_buffer_map = __skel->maps.ring_buffer_map;	     \
+		tuner->netns_map = __skel->maps.netns_map;		     \
+	} while (0)
+
+#define bpftuner_bpf_open(tuner_name, tuner) ({				     \
+	int __err = bpftune_cap_add();					     \
+                                                                             \
+	if (!__err) {							     \
+		tuner->name = #tuner_name;				     \
+		tuner->bpf_support = bpftune_bpf_support();		     \
+		switch (tuner->bpf_support) {				     \
+		case BPFTUNE_SUPPORT_NORMAL:				     \
+			__bpftuner_bpf_open(tuner_name, tuner, bpf);	     \
+			break;						     \
+		case BPFTUNE_SUPPORT_LEGACY:				     \
+			__bpftuner_bpf_open(tuner_name, tuner, bpf_legacy);  \
+			break;						     \
+		case BPFTUNE_SUPPORT_NOBTF:				     \
+			__bpftuner_bpf_open(tuner_name, tuner, bpf_nobtf);   \
+			break;						     \
+		default:						     \
+			break;						     \
 		}							     \
-		bpftuner_bpf_set_autoload(tuner);			     \
-	} while (0);							     \
-	bpftune_cap_drop();						     \
+		bpftune_cap_drop();					     \
+	}								     \
+	__err = libbpf_get_error(tuner->skel);				     \
 	if (__err) {							     \
-		tuner->skel = NULL;					     \
-		bpftuner_bpf_destroy(tuner_name, tuner);		     \
-		bpftune_log_bpf_err(__err, #tuner_name " open bpf: %s\n");   \
+		bpftune_log_bpf_err(__err,				     \
+				    #tuner_name " open bpf: %s\n");	     \
 	}								     \
 	__err;								     \
-	})
+})
 
 #define bpftuner_bpf_destroy(tuner_name, tuner)				     \
 	do {								     \
-		if (!tuner->bpf_legacy)					     \
+		switch (tuner->bpf_support) {				     \
+		case BPFTUNE_SUPPORT_NORMAL:				     \
 			tuner_name##_tuner_bpf__destroy(tuner->skel);	     \
-		else							     \
+			break;						     \
+		case BPFTUNE_SUPPORT_LEGACY:				     \
 			tuner_name##_tuner_bpf_legacy__destroy(tuner->skel); \
-		tuner->skel = NULL;					     \
+			break;						     \
+		case BPFTUNE_SUPPORT_NOBTF:				     \
+			tuner_name##_tuner_bpf_nobtf__destroy(tuner->skel);  \
+			break;						     \
+		default:						     \
+			break;						     \
+		}							     \
 	} while (0)
 
 #define _bpftuner_bpf_load(tuner_name, tuner, optionals) ({		     \
-	int __err = 0;							     \
-	do {								     \
-		struct tuner_name##_tuner_bpf *__skel = tuner->skel;	     \
-		struct tuner_name##_tuner_bpf_legacy *__lskel = tuner->skel; \
+	int __err;							     \
 									     \
-		__err = __bpftuner_bpf_load(tuner, optionals);		     \
-		if (__err) {						     \
-			bpftuner_bpf_destroy(tuner_name, tuner);	     \
-			break;						     \
-		}							     \
-		if (!tuner->bpf_legacy)					     \
-			__skel->bss->tuner_id = bpftune_tuner_num();	     \
-		else							     \
-			__lskel->bss->tuner_id = bpftune_tuner_num();	     \
-	} while (0);							     \
+	__err = __bpftuner_bpf_load(tuner, optionals);			     \
+	if (__err)							     \
+		bpftuner_bpf_destroy(tuner_name, tuner);		     \
 	__err;								     \
-	})
+})
 
 #define bpftuner_bpf_load(tuner_name, tuner)				     \
 	_bpftuner_bpf_load(tuner_name, tuner, NULL)
 
 #define bpftuner_bpf_attach(tuner_name, tuner, optionals) ({		     \
-	int __err = 0;							     \
-	do {								     \
-                __err = __bpftuner_bpf_attach(tuner);			     \
-		if (__err && optionals != NULL) {			     \
-			bpftuner_bpf_fini(tuner);			     \
-			__err = bpftuner_bpf_open(tuner_name, tuner);	     \
-			if (!__err)					     \
-			__err = _bpftuner_bpf_load(tuner_name, tuner,	     \
-						   optionals);    	     \
-			if (!__err)					     \
+	int __err = __bpftuner_bpf_attach(tuner);			     \
+                                                                             \
+	if (__err && optionals != NULL) {				     \
+		bpftuner_bpf_fini(tuner);			 	     \
+		__err = bpftuner_bpf_open(tuner_name, tuner);	 	     \
+		if (!__err)						     \
+			__err = _bpftuner_bpf_load(tuner_name, tuner, optionals); \
+		if (!__err)						     \
 			__err = __bpftuner_bpf_attach(tuner);		     \
-		}							     \
-                if (__err)                                                   \
-			bpftuner_bpf_destroy(tuner_name, tuner);	     \
-	} while (0);							     \
+	}								     \
 	__err;								     \
-	})
+})
 
 #define bpftuner_bpf_init(tuner_name, tuner, optionals) ({		     \
-	int __err = 0;							     \
-	do {								     \
-		__err = bpftuner_bpf_open(tuner_name, tuner);		     \
-		if (!__err)						     \
+	int __err = bpftuner_bpf_open(tuner_name, tuner);		     \
+									     \
+	if (!__err)							     \
 		__err = bpftuner_bpf_load(tuner_name, tuner);		     \
-		if (!__err)						     \
-		__err = bpftuner_bpf_attach(tuner_name, tuner, optionals);   \
-	} while (0);							     \
+	if (!__err)							     \
+		bpftuner_bpf_attach(tuner_name, tuner, optionals);	     \
 	__err;								     \
-	})
+})
 
 
 #define bpftuner_bpf_var_set(tuner_name, tuner, var, val)		     \
 	do {								     \
 		struct tuner_name##_tuner_bpf *__skel = tuner->skel;	     \
                 struct tuner_name##_tuner_bpf_legacy *__lskel = tuner->skel; \
-		if (tuner->bpf_legacy)					     \
+		struct tuner_name##_tuner_bpf_nobtf *__nskel = tuner->skel;  \
+		switch (tuner->bpf_support) {				     \
+		case BPFTUNE_SUPPORT_NORMAL:				     \
 			__skel->bss->var = val;				     \
-		else							     \
+			break;						     \
+		case BPFTUNE_SUPPORT_LEGACY:				     \
 			__lskel->bss->var = val;			     \
+			break;						     \
+		case BPFTUNE_SUPPORT_NOBTF:				     \
+			__nskel->bss->var = val;			     \
+		default:						     \
+			break;						     \
+		}							     \
 		bpftune_log(LOG_DEBUG, "%s: set variable '%s' = '%ld'\n",    \
 			    #tuner_name, #var, (long)val);		     \
 	} while (0)
 
 #define bpftuner_bpf_var_get(tuner_name, tuner, var)			     \
-	(tuner->bpf_legacy ?						     \
+	(tuner->bpf_support == BPFTUNE_SUPPORT_NORMAL ?		     \
+	 ((struct tuner_name##_tuner_bpf *)tuner->skel)->bss->var :    \
+	 tuner->bpf_support == BPFTUNE_SUPPORT_LEGACY ?		     \
 	 ((struct tuner_name##_tuner_bpf_legacy *)tuner->skel)->bss->var :   \
-	 ((struct tuner_name##_tuner_bpf *)tuner->skel)->bss->var)
-
-enum bpftune_support_level {
-	BPFTUNE_NONE = -1,
-	BPFTUNE_LEGACY,
-	BPFTUNE_NORMAL
-};
+	 ((struct tuner_name##_tuner_bpf_nobtf *)tuner->skel)->bss->var)
 
 enum bpftune_support_level bpftune_bpf_support(void);
-void bpftuner_force_bpf_legacy(void);
-bool bpftuner_bpf_legacy(void);
+bool bpftune_have_vmlinux_btf(void);
+void bpftune_force_bpf_support(enum bpftune_support_level);
+
 int bpftuner_ring_buffer_map_fd(struct bpftuner *tuner);
 void *bpftune_ring_buffer_init(int ringbuf_map_fd, void *ctx);
 int bpftune_ring_buffer_poll(void *ring_buffer, int interval);

sample_tuner/Makefile

@@ -92,9 +92,13 @@ $(BPF_OBJS): $(patsubst %.o,%.c,$(BPF_OBJS))
 		$(INCLUDES) -c $(patsubst %.o,%.c,$(@)) -o $(@);
 	$(CLANG) -g -D__TARGET_ARCH_$(SRCARCH) -DBPFTUNE_LEGACY -O2 -target bpf \
 		$(INCLUDES) -c $(patsubst %.o,%.c,$(@)) \
-		-o $(patsubst %.o,%.legacy.o,$(@))
+		-o $(patsubst %.o,%.legacy.o,$(@));
+	$(CLANG) -g -D__TARGET_ARCH_$(SRCARCH) -DBPFTUNE_NOBTF -DBPFTUNE_LEGACY -O2 -target bpf \
+		$(INCLUDES) -c $(patsubst %.o,%.c,$(@)) \
+		-o $(patsubst %.o,%.nobtf.o,$(@));
 
 $(BPF_SKELS): $(BPF_OBJS)
 	$(BPFTOOL) gen skeleton $(subst .skel.h,.bpf.o,$@) > $@ ;\
-	$(BPFTOOL) gen skeleton $(subst .skel.h,.bpf.legacy.o,$@) > $(subst .skel.h,.skel.legacy.h,$@)
+	$(BPFTOOL) gen skeleton $(subst .skel.h,.bpf.legacy.o,$@) > $(subst .skel.h,.skel.legacy.h,$@);\
+	$(BPFTOOL) gen skeleton $(subst .skel.h,.bpf.nobtf.o,$@) > $(subst .skel.h,.skel.nobtf.h,$@)
 

sample_tuner/sample_tuner.c

@@ -21,6 +21,7 @@
 #include <bpftune/bpftune.h>
 #include "sample_tuner.skel.h"
 #include "sample_tuner.skel.legacy.h"
+#include "sample_tuner.skel.nobtf.h"
 
 int init(struct bpftuner *tuner)
 {

src/Makefile

@@ -94,9 +94,11 @@ BPF_TUNERS = $(patsubst %,%.bpf.o,$(TUNERS))
 
 BPF_OBJS = $(BPF_TUNERS) probe.bpf.o
 LEGACY_BPF_OBJS = $(patsubst %.bpf.o,%.bpf.legacy.o,$(BPF_OBJS))
+NOBTF_BPF_OBJS = $(patsubst %.bpf.o,%.bpf.nobtf.o,$(BPF_OBJS))
 
 BPF_SKELS = $(patsubst %,%.skel.h,$(TUNERS)) probe.skel.h
 LEGACY_BPF_SKELS = $(patsubst %.skel.h,%.skel.legacy.h,$(BPF_SKELS))
+NOBTF_BPF_SKELS = $(patsubst %.skel.h,%.skel.nobtf.h,$(BPF_SKELS))
 
 .DELETE_ON_ERROR:
 
@@ -107,7 +109,7 @@ all: analyze $(OPATH) $(OPATH)bpftune $(TUNER_LIBS)
 $(OPATH):
 	mkdir $(OPATH)
 
-analyze: $(BPF_SKELS) $(LEGACY_BPF_SKELS)
+analyze: $(BPF_SKELS) $(LEGACY_BPF_SKELS) $(NOBTF_BPF_SKELS)
 	$(CLANG) --analyze $(INCLUDES) libbpftune.c bpftune.c $(TUNER_SRCS)
 clean:
 	$(call QUIET_CLEAN, bpftune)
@@ -146,13 +148,13 @@ $(OPATH)libbpftune.so: libbpftune.c ../include/bpftune/libbpftune.h $(OPATH)libb
 	rm -f $(@) ; \
 	ln -sr $(@).$(VERSION) $(@)
 
-$(TUNER_OBJS): $(BPF_SKELS) $(LEGACY_BPF_SKELS)
+$(TUNER_OBJS): $(BPF_SKELS) $(LEGACY_BPF_SKELS) $(NOBTF_BPF_SKELS)
 
 $(TUNER_LIBS): $(OPATH)libbpftune.so $(TUNER_OBJS)
 	$(CC) $(CFLAGS) -shared -o $(@) $(patsubst $(OPATH)%.so,%.c,$(@)) \
 		$(LDLIBS) -lbpftune $(LDFLAGS)
 
-$(OPATH)libbpftune.o: probe.skel.h probe.skel.legacy.h
+$(OPATH)libbpftune.o: probe.skel.h probe.skel.legacy.h probe.skel.nobtf.h
 	$(QUIET_CC)$(CC) $(CFLAGS) -c libbpftune.c -o $@
 
 $(OPATH)bpftune.o: $(OPATH)libbpftune.so
@@ -170,9 +172,17 @@ $(LEGACY_BPF_OBJS): $(patsubst %.legacy.o,%.c,$(LEGACY_BPF_OBJS))
 		$(INCLUDES) -c $(patsubst %.legacy.o,%.c,$(@)) \
 		-o $(@)
 
+$(NOBTF_BPF_OBJS): $(patsubst %.nobtf.o,%.c,$(NOBTF_BPF_OBJS))
+	$(CLANG) $(BPF_CFLAGS) -D__TARGET_ARCH_$(SRCARCH) -DBPFTUNE_NOBTF -O2 -target bpf \
+		$(INCLUDES) -c $(patsubst %.nobtf.o,%.c,$(@)) \
+		-o $(@)
+
 $(BPF_SKELS): $(BPF_OBJS)
 	$(BPFTOOL) gen skeleton $(subst .skel.h,.bpf.o,$@) > $@
 
 $(LEGACY_BPF_SKELS): $(LEGACY_BPF_OBJS)
 	$(BPFTOOL) gen skeleton $(subst .skel.legacy.h,.bpf.legacy.o,$@) > $(subst .skel.h,.skel.legacy.h,$@)
 
+$(NOBTF_BPF_SKELS): $(NOBTF_BPF_OBJS)
+	$(BPFTOOL) gen skeleton $(subst .skel.nobtf.h,.bpf.nobtf.o,$@) > $(subst .skel.h,.skel.nobtf.h,$@)
+