Skip to contentSkip to conversation

btf_encoder: refactor emission of BTF funcs

PATCH In review Ihor Solodrai 5 participants 12 messages Nov 6, 2025 – Nov 14, 2025 BPF

lore
Share & tools
lore

Ihor Solodrai

author reviewer
#0 lore raw

v4 cover btf_encoder: refactor emission of BTF funcs

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

Ihor Solodrai (3):
btf_encoder: Remove encoder pointer from btf_encoder_func_state
btf_encoder: Refactor btf_encoder__add_func_proto
btf_encoder: Factor out BPF kfunc emission

 btf_encoder.c | 206 +++++++++++++++++++++++++++++---------------------
 1 file changed, 119 insertions(+), 87 deletions(-)
Signature · 1 line
2.51.1
author reviewer
#1 lore raw

PATCH v4 1/3 btf_encoder: Remove encoder pointer from btf_encoder_func_state

Since multithreading was moved to dwarf_loader [1], pahole maintains a single global btf_encoder instance. However parts of btf_encoder.c exist to manage mulitple encoders, which is not necessary anymore.

This patch removes encoder pointer from struct btf_encoder_func_state. We create a state for every encountered instance of a function in DWARF, and currently they carry around the encoder unnecessarily.

[1] https://lore.kernel.org/all/[email protected]/

---
 btf_encoder.c | 34 +++++++++++++++-------------------
 1 file changed, 15 insertions(+), 19 deletions(-)
btf_encoder.c +15 -19
index 03bc3c7..a6fdc58 100644
@@ -79,7 +79,6 @@ struct btf_encoder_func_annot {
 
 /* state used to do later encoding of saved functions */
 struct btf_encoder_func_state {
-	struct btf_encoder *encoder;
 	struct elf_function *elf;
 	uint32_t type_id_off;
 	uint16_t nr_parms;
@@ -819,7 +818,7 @@ static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct f
 					   struct btf_encoder_func_state *state)
 {
 	const struct btf_type *t;
-	struct btf *btf;
+	struct btf *btf = encoder->btf;
 	struct parameter *param;
 	uint16_t nr_params, param_idx;
 	int32_t id, type_id;
@@ -834,12 +833,9 @@ static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct f
 
 	/* add btf_type for func_proto */
 	if (ftype) {
-		btf = encoder->btf;
 		nr_params = ftype->nr_parms + (ftype->unspec_parms ? 1 : 0);
 		type_id = btf_encoder__tag_type(encoder, ftype->tag.type);
 	} else if (state) {
-		encoder = state->encoder;
-		btf = state->encoder->btf;
 		nr_params = state->nr_parms;
 		type_id = state->ret_type_id;
 	} else {
@@ -1123,13 +1119,12 @@ static bool types__match(struct btf_encoder *encoder,
 	return false;
 }
 
-static bool funcs__match(struct btf_encoder_func_state *s1,
+static bool funcs__match(struct btf_encoder *encoder,
+			 struct btf_encoder_func_state *s1,
 			 struct btf_encoder_func_state *s2)
 {
-	struct btf_encoder *encoder = s1->encoder;
 	struct elf_function *func = s1->elf;
-	struct btf *btf1 = s1->encoder->btf;
-	struct btf *btf2 = s2->encoder->btf;
+	struct btf *btf = encoder->btf;
 	uint8_t i;
 
 	if (s1->nr_parms != s2->nr_parms) {
@@ -1138,7 +1133,7 @@ static bool funcs__match(struct btf_encoder_func_state *s1,
 					   s1->nr_parms, s2->nr_parms);
 		return false;
 	}
-	if (!types__match(encoder, btf1, s1->ret_type_id, btf2, s2->ret_type_id)) {
+	if (!types__match(encoder, btf, s1->ret_type_id, btf, s2->ret_type_id)) {
 		btf_encoder__log_func_skip(encoder, func, "return type mismatch\n");
 		return false;
 	}
@@ -1146,11 +1141,11 @@ static bool funcs__match(struct btf_encoder_func_state *s1,
 		return true;
 
 	for (i = 0; i < s1->nr_parms; i++) {
-		if (!types__match(encoder, btf1, s1->parms[i].type_id,
-				  btf2, s2->parms[i].type_id)) {
+		if (!types__match(encoder, btf, s1->parms[i].type_id,
+				  btf, s2->parms[i].type_id)) {
 			if (encoder->verbose) {
-				const char *p1 = btf__name_by_offset(btf1, s1->parms[i].name_off);
-				const char *p2 = btf__name_by_offset(btf2, s2->parms[i].name_off);
+				const char *p1 = btf__name_by_offset(btf, s1->parms[i].name_off);
+				const char *p2 = btf__name_by_offset(btf, s2->parms[i].name_off);
 
 				btf_encoder__log_func_skip(encoder, func,
 							   "param type mismatch for param#%d %s %s %s\n",
@@ -1244,7 +1239,6 @@ static int32_t btf_encoder__save_func(struct btf_encoder *encoder, struct functi
 	if (!state)
 		return -ENOMEM;
 
-	state->encoder = encoder;
 	state->elf = func;
 	state->nr_parms = ftype->nr_parms + (ftype->unspec_parms ? 1 : 0);
 	state->ret_type_id = ftype->tag.type == 0 ? 0 : encoder->type_id_off + ftype->tag.type;
@@ -1410,7 +1404,9 @@ static int saved_functions_cmp(const void *_a, const void *_b)
 	return elf_function__name_cmp(a->elf, b->elf);
 }
 
-static int saved_functions_combine(struct btf_encoder_func_state *a, struct btf_encoder_func_state *b)
+static int saved_functions_combine(struct btf_encoder *encoder,
+				   struct btf_encoder_func_state *a,
+				   struct btf_encoder_func_state *b)
 {
 	uint8_t optimized, unexpected, inconsistent, uncertain_parm_loc;
 
@@ -1421,7 +1417,7 @@ static int saved_functions_combine(struct btf_encoder_func_state *a, struct btf_
 	unexpected = a->unexpected_reg | b->unexpected_reg;
 	inconsistent = a->inconsistent_proto | b->inconsistent_proto;
 	uncertain_parm_loc = a->uncertain_parm_loc | b->uncertain_parm_loc;
-	if (!unexpected && !inconsistent && !funcs__match(a, b))
+	if (!unexpected && !inconsistent && !funcs__match(encoder, a, b))
 		inconsistent = 1;
 	a->optimized_parms = b->optimized_parms = optimized;
 	a->unexpected_reg = b->unexpected_reg = unexpected;
@@ -1471,7 +1467,7 @@ static int btf_encoder__add_saved_funcs(struct btf_encoder *encoder, bool skip_e
 		 */
 		j = i + 1;
 
-		while (j < nr_saved_fns && saved_functions_combine(&saved_fns[i], &saved_fns[j]) == 0)
+		while (j < nr_saved_fns && saved_functions_combine(encoder, &saved_fns[i], &saved_fns[j]) == 0)
 			j++;
 
 		/* do not exclude functions with optimized-out parameters; they
@@ -1488,7 +1484,7 @@ static int btf_encoder__add_saved_funcs(struct btf_encoder *encoder, bool skip_e
 					0, 0);
 
 		if (add_to_btf) {
-			err = btf_encoder__add_func(state->encoder, state);
+			err = btf_encoder__add_func(encoder, state);
 			if (err < 0)
 				goto out;
 		}
Signature · 1 line
2.51.1
author reviewer
#2 lore raw

PATCH v4 2/3 btf_encoder: Refactor btf_encoder__add_func_proto

In reply to Ihor Solodrai

btf_encoder__add_func_proto() essentially implements two independent code paths depending on input arguments: one for struct ftype and the other for struct btf_encoder_func_state.

Split btf_encoder__add_func_proto() into two variants:
* btf_encoder__add_func_proto_for_ftype()
* btf_encoder__add_func_proto_for_state()

And factor out common btf_encoder__emit_func_proto() subroutine.

No functional changes.

---
 btf_encoder.c | 135 +++++++++++++++++++++++++++++---------------------
 1 file changed, 79 insertions(+), 56 deletions(-)
btf_encoder.c +79 -56
index a6fdc58..bdda7d0 100644
@@ -814,79 +814,102 @@ static inline bool is_kfunc_state(struct btf_encoder_func_state *state)
 	return state && state->elf && state->elf->kfunc;
 }
 
-static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct ftype *ftype,
-					   struct btf_encoder_func_state *state)
+static int32_t btf_encoder__emit_func_proto(struct btf_encoder *encoder,
+					    uint32_t type_id,
+					    uint16_t nr_params)
 {
 	const struct btf_type *t;
-	struct btf *btf = encoder->btf;
-	struct parameter *param;
+	uint32_t ret;
+
+	ret = btf__add_func_proto(encoder->btf, type_id);
+	if (ret > 0) {
+		t = btf__type_by_id(encoder->btf, ret);
+		btf_encoder__log_type(encoder, t, false, false,
+			"return=%u args=(%s", t->type, !nr_params ? "void)\n" : "");
+	} else {
+		btf__log_err(encoder->btf, BTF_KIND_FUNC_PROTO, NULL, true, ret,
+			     "return=%u vlen=%u Error emitting BTF type",
+			     type_id, nr_params);
+	}
+
+	return ret;
+}
+
+static int32_t btf_encoder__add_func_proto_for_ftype(struct btf_encoder *encoder,
+						     struct ftype *ftype)
+{
 	uint16_t nr_params, param_idx;
+	struct parameter *param;
 	int32_t id, type_id;
-	char tmp_name[KSYM_NAME_LEN];
 	const char *name;
 
-	assert(ftype != NULL || state != NULL);
-
-	if (is_kfunc_state(state) && encoder->tag_kfuncs && encoder->encode_attributes)
-		if (btf__add_bpf_arena_type_tags(encoder->btf, state) < 0)
-			return -1;
+	assert(ftype != NULL);
 
 	/* add btf_type for func_proto */
-	if (ftype) {
-		nr_params = ftype->nr_parms + (ftype->unspec_parms ? 1 : 0);
-		type_id = btf_encoder__tag_type(encoder, ftype->tag.type);
-	} else if (state) {
-		nr_params = state->nr_parms;
-		type_id = state->ret_type_id;
-	} else {
-		return 0;
-	}
+	nr_params = ftype->nr_parms + (ftype->unspec_parms ? 1 : 0);
+	type_id = btf_encoder__tag_type(encoder, ftype->tag.type);
 
-	id = btf__add_func_proto(btf, type_id);
-	if (id > 0) {
-		t = btf__type_by_id(btf, id);
-		btf_encoder__log_type(encoder, t, false, false, "return=%u args=(%s", t->type, !nr_params ? "void)\n" : "");
-	} else {
-		btf__log_err(btf, BTF_KIND_FUNC_PROTO, NULL, true, id,
-			     "return=%u vlen=%u Error emitting BTF type",
-			     type_id, nr_params);
+	id = btf_encoder__emit_func_proto(encoder, type_id, nr_params);
+	if (id < 0)
 		return id;
-	}
 
 	/* add parameters */
 	param_idx = 0;
-	if (ftype) {
-		ftype__for_each_parameter(ftype, param) {
-			const char *name = parameter__name(param);
-
-			type_id = param->tag.type == 0 ? 0 : encoder->type_id_off + param->tag.type;
-			++param_idx;
-			if (btf_encoder__add_func_param(encoder, name, type_id,
-							param_idx == nr_params))
-				return -1;
-		}
 
+	ftype__for_each_parameter(ftype, param) {
+		name = parameter__name(param);
+		type_id = param->tag.type == 0 ? 0 : encoder->type_id_off + param->tag.type;
 		++param_idx;
-		if (ftype->unspec_parms)
-			if (btf_encoder__add_func_param(encoder, NULL, 0,
-							param_idx == nr_params))
-				return -1;
-	} else {
-		for (param_idx = 0; param_idx < nr_params; param_idx++) {
-			struct btf_encoder_func_parm *p = &state->parms[param_idx];
+		if (btf_encoder__add_func_param(encoder, name, type_id, param_idx == nr_params))
+			return -1;
+	}
 
-			name = btf__name_by_offset(btf, p->name_off);
+	++param_idx;
+	if (ftype->unspec_parms)
+		if (btf_encoder__add_func_param(encoder, NULL, 0, param_idx == nr_params))
+			return -1;
 
-			/* adding BTF data may result in a move of the
-			 * name string memory, so make a temporary copy.
-			 */
-			strncpy(tmp_name, name, sizeof(tmp_name) - 1);
+	return id;
+}
 
-			if (btf_encoder__add_func_param(encoder, tmp_name, p->type_id,
-							param_idx == nr_params))
-				return -1;
-		}
+static int32_t btf_encoder__add_func_proto_for_state(struct btf_encoder *encoder,
+						     struct btf_encoder_func_state *state)
+{
+	const struct btf *btf = encoder->btf;
+	struct btf_encoder_func_parm *p;
+	uint16_t nr_params, param_idx;
+	char tmp_name[KSYM_NAME_LEN];
+	int32_t id, type_id;
+	const char *name;
+	bool is_last;
+
+	/* Beware: btf__add_bpf_arena_type_tags may change some members of the state */
+	if (is_kfunc_state(state) && encoder->tag_kfuncs && encoder->encode_attributes)
+		if (btf__add_bpf_arena_type_tags(encoder->btf, state) < 0)
+			return -1;
+
+	type_id = state->ret_type_id;
+	nr_params = state->nr_parms;
+
+	id = btf_encoder__emit_func_proto(encoder, type_id, nr_params);
+	if (id < 0)
+		return id;
+
+	/* add parameters */
+	for (param_idx = 0; param_idx < nr_params; param_idx++) {
+		p = &state->parms[param_idx];
+		name = btf__name_by_offset(btf, p->name_off);
+		is_last = param_idx == nr_params;
+
+		/* adding BTF data may result in a move of the
+		 * name string memory, so make a temporary copy.
+		 */
+		strncpy(tmp_name, name, sizeof(tmp_name) - 1);
+
+		if (btf_encoder__add_func_param(encoder, tmp_name, p->type_id, is_last))
+			return -1;
 	}
+
 	return id;
 }
 
@@ -1343,7 +1366,7 @@ static int32_t btf_encoder__add_func(struct btf_encoder *encoder,
 	uint16_t idx;
 	int err;
 
-	btf_fnproto_id = btf_encoder__add_func_proto(encoder, NULL, state);
+	btf_fnproto_id = btf_encoder__add_func_proto_for_state(encoder, state);
 	name = func->name;
 	if (btf_fnproto_id >= 0)
 		btf_fn_id = btf_encoder__add_ref_type(encoder, BTF_KIND_FUNC, btf_fnproto_id,
@@ -1682,7 +1705,7 @@ static int btf_encoder__encode_tag(struct btf_encoder *encoder, struct tag *tag,
 	case DW_TAG_enumeration_type:
 		return btf_encoder__add_enum_type(encoder, tag, conf_load);
 	case DW_TAG_subroutine_type:
-		return btf_encoder__add_func_proto(encoder, tag__ftype(tag), NULL);
+		return btf_encoder__add_func_proto_for_ftype(encoder, tag__ftype(tag));
         case DW_TAG_unspecified_type:
 		/* Just don't encode this for now, converting anything with this type to void (0) instead.
 		 *
Signature · 1 line
2.51.1
author reviewer
#3 lore raw

PATCH v4 3/3 btf_encoder: Factor out BPF kfunc emission

In reply to Ihor Solodrai

Generating BTF for BPF kernel functions requires special handling. Consolidate this behavior into btf_encoder__add_bpf_kfunc(), which uses simplified btf_encoder_add_func().

No functional changes.

---
 btf_encoder.c | 51 ++++++++++++++++++++++++++++++++-------------------
 1 file changed, 32 insertions(+), 19 deletions(-)
btf_encoder.c +32 -19
index bdda7d0..b37ee7f 100644
@@ -773,6 +773,7 @@ static int btf__tag_bpf_arena_arg(struct btf *btf, struct btf_encoder_func_state
 	return id;
 }
 
+/* Modifies state->ret_type_id and state->parms[i].type_id for flagged kfuncs */
 static int btf__add_bpf_arena_type_tags(struct btf *btf, struct btf_encoder_func_state *state)
 {
 	uint32_t flags = state->elf->kfunc_flags;
@@ -883,11 +884,6 @@ static int32_t btf_encoder__add_func_proto_for_state(struct btf_encoder *encoder
 	const char *name;
 	bool is_last;
 
-	/* Beware: btf__add_bpf_arena_type_tags may change some members of the state */
-	if (is_kfunc_state(state) && encoder->tag_kfuncs && encoder->encode_attributes)
-		if (btf__add_bpf_arena_type_tags(encoder->btf, state) < 0)
-			return -1;
-
 	type_id = state->ret_type_id;
 	nr_params = state->nr_parms;
 
@@ -1357,14 +1353,13 @@ static int btf__tag_kfunc(struct btf *btf, struct elf_function *kfunc, __u32 btf
 static int32_t btf_encoder__add_func(struct btf_encoder *encoder,
 				     struct btf_encoder_func_state *state)
 {
-	struct elf_function *func = state->elf;
 	int btf_fnproto_id, btf_fn_id, tag_type_id = 0;
+	struct elf_function *func = state->elf;
+	char tmp_value[KSYM_NAME_LEN];
 	int16_t component_idx = -1;
-	const char *name;
 	const char *value;
-	char tmp_value[KSYM_NAME_LEN];
+	const char *name;
 	uint16_t idx;
-	int err;
 
 	btf_fnproto_id = btf_encoder__add_func_proto_for_state(encoder, state);
 	name = func->name;
@@ -1377,15 +1372,6 @@ static int32_t btf_encoder__add_func(struct btf_encoder *encoder,
 		return -1;
 	}
 
-	if (func->kfunc && encoder->tag_kfuncs && !encoder->skip_encoding_decl_tag) {
-		err = btf__tag_kfunc(encoder->btf, func, btf_fn_id);
-		if (err < 0)
-			return err;
-	}
-
-	if (state->nr_annots == 0)
-		return 0;
-
 	for (idx = 0; idx < state->nr_annots; idx++) {
 		struct btf_encoder_func_annot *a = &state->annots[idx];
 
@@ -1408,6 +1394,30 @@ static int32_t btf_encoder__add_func(struct btf_encoder *encoder,
 		return -1;
 	}
 
+	return btf_fn_id;
+}
+
+static int btf_encoder__add_bpf_kfunc(struct btf_encoder *encoder,
+				      struct btf_encoder_func_state *state)
+{
+	int btf_fn_id, err;
+
+	if (encoder->tag_kfuncs && encoder->encode_attributes) {
+		err = btf__add_bpf_arena_type_tags(encoder->btf, state);
+		if (err < 0)
+			return err;
+	}
+
+	btf_fn_id = btf_encoder__add_func(encoder, state);
+	if (btf_fn_id < 0)
+		return -1;
+
+	if (encoder->tag_kfuncs && !encoder->skip_encoding_decl_tag) {
+		err = btf__tag_kfunc(encoder->btf, state->elf, btf_fn_id);
+		if (err < 0)
+			return err;
+	}
+
 	return 0;
 }
 
@@ -1507,7 +1517,10 @@ static int btf_encoder__add_saved_funcs(struct btf_encoder *encoder, bool skip_e
 					0, 0);
 
 		if (add_to_btf) {
-			err = btf_encoder__add_func(encoder, state);
+			if (is_kfunc_state(state))
+				err = btf_encoder__add_bpf_kfunc(encoder, state);
+			else
+				err = btf_encoder__add_func(encoder, state);
 			if (err < 0)
 				goto out;
 		}
Signature · 1 line
2.51.1
#4 lore raw
In reply to Ihor Solodrai
Quoted 10 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Thank you!

Quoted 8 lines

Ihor Solodrai (3):
btf_encoder: Remove encoder pointer from btf_encoder_func_state
btf_encoder: Refactor btf_encoder__add_func_proto
btf_encoder: Factor out BPF kfunc emission

 btf_encoder.c | 206 +++++++++++++++++++++++++++++---------------------
 1 file changed, 119 insertions(+), 87 deletions(-)
#5 lore raw
Quoted 8 lines · Alan Maguire
Quoted 6 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

Quoted 7 lines
Quoted 4 lines

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Same rant as before...
Can we please keep it normal with all changes going to master ? This 'next' branch confused people in the past.
I see no value in this 'next' thing.
All development should happen in master and every developer should base their changes on top of it.
Eventually the release happens out of master too when it's deemed stable.

#6 lore raw
Quoted 14 lines · Alexei Starovoitov
Quoted 13 lines · Alan Maguire
Quoted 10 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

Quoted 6 lines
Quoted 2 lines

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Same rant as before...
Can we please keep it normal with all changes going to master ? This 'next' branch confused people in the past.

I think the problem before was that it sat there for far too long.

I see value in it staying there for a short period for some eventual rebase and for some CI thing, to avoid polluting, think of it as some topic branch on the way to master.

- Arnaldo

Quoted 4 lines

I see no value in this 'next' thing.
All development should happen in master and every developer should base their changes on top of it.
Eventually the release happens out of master too when it's deemed stable.

#7 lore raw
Quoted 23 lines · Arnaldo Carvalho de Melo
Quoted 14 lines · Alexei Starovoitov
Quoted 13 lines · Alan Maguire
Quoted 10 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

Quoted 6 lines
Quoted 2 lines

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Same rant as before...
Can we please keep it normal with all changes going to master ? This 'next' branch confused people in the past.

Quoted 5 lines

I think the problem before was that it sat there for far too long.

I see value in it staying there for a short period for some eventual rebase and for some CI thing, to avoid polluting, think of it as some topic branch on the way to master.

I'm still missing the value proposition.
Right now Yonghong is also sending pahole patches, Ihor will start moving things from pahole to resolve_btfid, Donglin ais lso working on btf sorting,
and finally Alan has large loc* patchset.
Some or all of them will conflict.

What do they suppose to use as a base? 'next' branch? All of them or some?
How will you differentiate and educate developers ?

Really, 'next' branch is not a good idea.

#8 lore raw
In reply to Arnaldo Carvalho de Melo
Quoted 22 lines · Arnaldo Carvalho de Melo
Quoted 14 lines · Alexei Starovoitov
Quoted 13 lines · Alan Maguire
Quoted 10 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

Quoted 6 lines
Quoted 2 lines

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Same rant as before...
Can we please keep it normal with all changes going to master ? This 'next' branch confused people in the past.

Quoted 6 lines

I think the problem before was that it sat there for far too long.

I see value in it staying there for a short period for some eventual rebase and for some CI thing, to avoid polluting, think of it as some topic branch on the way to master.

Yeah, I think if we can augment CI to cover more we can narrow this window, aiming for zero as the test coverage improves. The other thing we should think about maybe is syncing github.com/acmel/dwarves with pahole.git as many people are pulling from github. Should we discourage using the github repo, or just find a way to mirror pahole.git automatically? Thanks!

Alan

Quoted 7 lines

- Arnaldo

Quoted 4 lines

I see no value in this 'next' thing.
All development should happen in master and every developer should base their changes on top of it.
Eventually the release happens out of master too when it's deemed stable.

#9 lore raw

7

Quoted 25 lines · Alan Maguire
Quoted 24 lines · Arnaldo Carvalho de Melo
Quoted 14 lines · Alexei Starovoitov
Quoted 13 lines · Alan Maguire
Quoted 10 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

Quoted 6 lines
Quoted 2 lines

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Same rant as before...
Can we please keep it normal with all changes going to master ? This 'next' branch confused people in the past.

I think the problem before was that it sat there for far too long.

Quoted 7 lines
Quoted 4 lines

I see value in it staying there for a short period for some eventual rebase and for some CI thing, to avoid polluting, think of it as some topic branch on the way to master.

Yeah, I think if we can augment CI to cover more we can narrow this window, aiming for zero as the test coverage improves.

I slept over this and think that is we can have the CI test patches directly from the mailing list, doing AI reviewing even, then the next thing can get a good riddance.

The other thing

Quoted 4 lines

we should think about maybe is syncing github.com/acmel/dwarves with pahole.git as many people are pulling from github. Should we discourage using the github repo, or just find a way to mirror pahole.git automatically? Thanks!

I think we should create a GitHub.com/pahole/ and have shared maintainership, will look into that.

Meanwhile, today, I'll check what's in next, test it and move it to master both in kernel.org and GitHub.

- Arnaldo

Quoted 11 lines

Alan

Quoted 7 lines

- Arnaldo

Quoted 4 lines

I see no value in this 'next' thing.
All development should happen in master and every developer should base their changes on top of it.
Eventually the release happens out of master too when it's deemed stable.

- Arnaldo

#10 lore raw
In reply to Alan Maguire
Quoted 22 lines · Alan Maguire
Quoted 21 lines · Arnaldo Carvalho de Melo
Quoted 19 lines · Alexei Starovoitov
Quoted 8 lines · Alan Maguire
Quoted 5 lines · Ihor Solodrai

This series refactors a few functions that handle how BTF functions are emitted.

v3->v4: Error handling nit from Eduard
v2->v3: Add patch removing encoder from btf_encoder_func_state

Quoted 6 lines
Quoted 3 lines

v3: https://lore.kernel.org/dwarves/[email protected]/
v2: https://lore.kernel.org/dwarves/[email protected]/
v1: https://lore.kernel.org/dwarves/[email protected]/

series applied to the next branch of
https://git.kernel.org/pub/scm/devel/pahole/pahole.git/

Same rant as before...
Can we please keep it normal with all changes going to master ? This 'next' branch confused people in the past.

Quoted 5 lines
Quoted 5 lines

I think the problem before was that it sat there for far too long.

I see value in it staying there for a short period for some eventual rebase and for some CI thing, to avoid polluting, think of it as some topic branch on the way to master.

Somehow my reply via the smartphone didn't seem to have made to the list...

Quoted 2 lines

Yeah, I think if we can augment CI to cover more we can narrow this window, aiming for zero as the test coverage improves.

So the 'next' is an artifact for CI usage, i.e. if we just don't announce that it was merged, do it for the CI sake and then when it runs and don't detect any problem we go ahead and merge into master and announce that it was merged, nothing of this drama would take place.

The best thing going forward I think is to have AI reviewing just like with the BPF patches, having the patches, once posted to the list by the contributors, trigger the CI, that amongst other things do the AI reviewing, if all is ok, maintainers get some nudge that AI bot is ok, etc and merge it in master, annouce publicly, yadda, yadda.

Quoted 5 lines

The other thing we should think about maybe is syncing github.com/acmel/dwarves with pahole.git as many people are pulling from github.
Should we discourage using the github repo, or just find a way to mirror pahole.git automatically? Thanks!

I think we should have a https://github.com/pahole/ area that is administered by the pahole maintainer(s), just like there are:

https://git.kernel.org/pub/scm/linux/kernel/git/perf/perf-tools.git/
https://git.kernel.org/pub/scm/linux/kernel/git/perf/perf-tools-next.git/

For the project (current merge window, next merge window) and my personal, previously canonical, perf and other kernel work repo:

https://git.kernel.org/pub/scm/linux/kernel/git/acme/linux.git/

:-)

- Arnaldo

#11 lore raw
Quoted 8 lines · Arnaldo Carvalho de Melo
Quoted 2 lines · Alan Maguire

Yeah, I think if we can augment CI to cover more we can narrow this window, aiming for zero as the test coverage improves.

So the 'next' is an artifact for CI usage, i.e. if we just don't announce that it was merged, do it for the CI sake and then when it runs and don't detect any problem we go ahead and merge into master and announce that it was merged, nothing of this drama would take place.

BTW, I looked at the patches, ran tests and merged next into master, pushed out to master in both kernel.org and github.

- Arnaldo