[bpf-next,v11,04/13] bpf: add struct_ops_tab to btf.

Commit Message

Kui-Feng Lee Nov. 6, 2023, 8:12 p.m. UTC

From: Kui-Feng Lee <[e-mail]>

Maintain a registry of registered struct_ops types in the per-btf (module)
struct_ops_tab. This registry allows for easy lookup of struct_ops types
that are registered by a specific module.

It is a preparation work for supporting kernel module struct_ops in a
latter patch. Each struct_ops will be registered under its own kernel
module btf and will be stored in the newly added btf->struct_ops_tab. The
bpf verifier and bpf syscall (e.g. prog and map cmd) can find the
struct_ops and its btf type/size/id... information from
btf->struct_ops_tab.

Signed-off-by: Kui-Feng Lee <[e-mail]>
---
 include/linux/btf.h |  8 +++++
 kernel/bpf/btf.c    | 83 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 91 insertions(+)

Comments

Martin KaFai Lau Nov. 10, 2023, 1:35 a.m. UTC | #1

On 11/6/23 12:12 PM, [e-mail] wrote:
> From: Kui-Feng Lee <[e-mail]>
> 
> Maintain a registry of registered struct_ops types in the per-btf (module)
> struct_ops_tab. This registry allows for easy lookup of struct_ops types
> that are registered by a specific module.
> 
> It is a preparation work for supporting kernel module struct_ops in a
> latter patch. Each struct_ops will be registered under its own kernel
> module btf and will be stored in the newly added btf->struct_ops_tab. The
> bpf verifier and bpf syscall (e.g. prog and map cmd) can find the
> struct_ops and its btf type/size/id... information from
> btf->struct_ops_tab.
> 
> Signed-off-by: Kui-Feng Lee <[e-mail]>
> ---
>   include/linux/btf.h |  8 +++++
>   kernel/bpf/btf.c    | 83 +++++++++++++++++++++++++++++++++++++++++++++
>   2 files changed, 91 insertions(+)
> 
> diff --git a/include/linux/btf.h b/include/linux/btf.h
> index c2231c64d60b..07ee6740e06a 100644
> --- a/include/linux/btf.h
> +++ b/include/linux/btf.h
> @@ -572,4 +572,12 @@ static inline bool btf_type_is_struct_ptr(struct btf *btf, const struct btf_type
>   	return btf_type_is_struct(t);
>   }
>   
> +#ifdef CONFIG_BPF_JIT

There are many new ifdef CONFIG_BPF_JIT in btf.{h,c}. Could it be avoided? For 
example, having an empty bpf_struct_ops_desc_init() for the not CONFIG_BPF_JIT 
case, is it enough?


> +struct bpf_struct_ops_desc;
> +
> +const struct bpf_struct_ops_desc *
> +btf_get_struct_ops(struct btf *btf, u32 *ret_cnt);
> +
> +#endif /* CONFIG_BPF_JIT */
> +
>   #endif

Kui-Feng Lee Nov. 22, 2023, 2:27 a.m. UTC | #2

On 11/9/23 17:35, Martin KaFai Lau wrote:
> On 11/6/23 12:12 PM, [e-mail] wrote:
>> From: Kui-Feng Lee <[e-mail]>
>>
>> Maintain a registry of registered struct_ops types in the per-btf 
>> (module)
>> struct_ops_tab. This registry allows for easy lookup of struct_ops types
>> that are registered by a specific module.
>>
>> It is a preparation work for supporting kernel module struct_ops in a
>> latter patch. Each struct_ops will be registered under its own kernel
>> module btf and will be stored in the newly added btf->struct_ops_tab. The
>> bpf verifier and bpf syscall (e.g. prog and map cmd) can find the
>> struct_ops and its btf type/size/id... information from
>> btf->struct_ops_tab.
>>
>> Signed-off-by: Kui-Feng Lee <[e-mail]>
>> ---
>>   include/linux/btf.h |  8 +++++
>>   kernel/bpf/btf.c    | 83 +++++++++++++++++++++++++++++++++++++++++++++
>>   2 files changed, 91 insertions(+)
>>
>> diff --git a/include/linux/btf.h b/include/linux/btf.h
>> index c2231c64d60b..07ee6740e06a 100644
>> --- a/include/linux/btf.h
>> +++ b/include/linux/btf.h
>> @@ -572,4 +572,12 @@ static inline bool btf_type_is_struct_ptr(struct 
>> btf *btf, const struct btf_type
>>       return btf_type_is_struct(t);
>>   }
>> +#ifdef CONFIG_BPF_JIT
> 
> There are many new ifdef CONFIG_BPF_JIT in btf.{h,c}. Could it be 
> avoided? For example, having an empty bpf_struct_ops_desc_init() for the 
> not CONFIG_BPF_JIT case, is it enough?

It is enough. However, it also leaves dead code.
Anyway, I just removed these conditions as you said.

> 
> 
>> +struct bpf_struct_ops_desc;
>> +
>> +const struct bpf_struct_ops_desc *
>> +btf_get_struct_ops(struct btf *btf, u32 *ret_cnt);
>> +
>> +#endif /* CONFIG_BPF_JIT */
>> +
>>   #endif
>

Patch

diff --git a/include/linux/btf.h b/include/linux/btf.h
index c2231c64d60b..07ee6740e06a 100644
--- a/include/linux/btf.h
+++ b/include/linux/btf.h
@@ -572,4 +572,12 @@  static inline bool btf_type_is_struct_ptr(struct btf *btf, const struct btf_type
 	return btf_type_is_struct(t);
 }
 
+#ifdef CONFIG_BPF_JIT
+struct bpf_struct_ops_desc;
+
+const struct bpf_struct_ops_desc *
+btf_get_struct_ops(struct btf *btf, u32 *ret_cnt);
+
+#endif /* CONFIG_BPF_JIT */
+
 #endif
diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 15d71d2986d3..263715af10cb 100644
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -241,6 +241,14 @@  struct btf_id_dtor_kfunc_tab {
 	struct btf_id_dtor_kfunc dtors[];
 };
 
+#ifdef CONFIG_BPF_JIT
+struct btf_struct_ops_tab {
+	u32 cnt;
+	u32 capacity;
+	struct bpf_struct_ops_desc ops[];
+};
+#endif /* CONFIG_BPF_JIT */
+
 struct btf {
 	void *data;
 	struct btf_type **types;
@@ -258,6 +266,9 @@  struct btf {
 	struct btf_kfunc_set_tab *kfunc_set_tab;
 	struct btf_id_dtor_kfunc_tab *dtor_kfunc_tab;
 	struct btf_struct_metas *struct_meta_tab;
+#ifdef CONFIG_BPF_JIT
+	struct btf_struct_ops_tab *struct_ops_tab;
+#endif /* CONFIG_BPF_JIT */
 
 	/* split BTF support */
 	struct btf *base_btf;
@@ -1688,11 +1699,22 @@  static void btf_free_struct_meta_tab(struct btf *btf)
 	btf->struct_meta_tab = NULL;
 }
 
+static void btf_free_struct_ops_tab(struct btf *btf)
+{
+#ifdef CONFIG_BPF_JIT
+	struct btf_struct_ops_tab *tab = btf->struct_ops_tab;
+
+	kfree(tab);
+	btf->struct_ops_tab = NULL;
+#endif
+}
+
 static void btf_free(struct btf *btf)
 {
 	btf_free_struct_meta_tab(btf);
 	btf_free_dtor_kfunc_tab(btf);
 	btf_free_kfunc_set_tab(btf);
+	btf_free_struct_ops_tab(btf);
 	kvfree(btf->types);
 	kvfree(btf->resolved_sizes);
 	kvfree(btf->resolved_ids);
@@ -8602,3 +8624,64 @@  bool btf_type_ids_nocast_alias(struct bpf_verifier_log *log,
 
 	return !strncmp(reg_name, arg_name, cmp_len);
 }
+
+#ifdef CONFIG_BPF_JIT
+
+static int
+btf_add_struct_ops(struct btf *btf, struct bpf_struct_ops *st_ops)
+{
+	struct btf_struct_ops_tab *tab, *new_tab;
+	int i;
+
+	if (!btf)
+		return -ENOENT;
+
+	/* Assume this function is called for a module when the module is
+	 * loading.
+	 */
+
+	tab = btf->struct_ops_tab;
+	if (!tab) {
+		tab = kzalloc(offsetof(struct btf_struct_ops_tab, ops[4]),
+			      GFP_KERNEL);
+		if (!tab)
+			return -ENOMEM;
+		tab->capacity = 4;
+		btf->struct_ops_tab = tab;
+	}
+
+	for (i = 0; i < tab->cnt; i++)
+		if (tab->ops[i].st_ops == st_ops)
+			return -EEXIST;
+
+	if (tab->cnt == tab->capacity) {
+		new_tab = krealloc(tab,
+				   offsetof(struct btf_struct_ops_tab,
+					    ops[tab->capacity * 2]),
+				   GFP_KERNEL);
+		if (!new_tab)
+			return -ENOMEM;
+		tab = new_tab;
+		tab->capacity *= 2;
+		btf->struct_ops_tab = tab;
+	}
+
+	tab->ops[btf->struct_ops_tab->cnt].st_ops = st_ops;
+
+	btf->struct_ops_tab->cnt++;
+
+	return 0;
+}
+
+const struct bpf_struct_ops_desc *btf_get_struct_ops(struct btf *btf, u32 *ret_cnt)
+{
+	if (!btf)
+		return NULL;
+	if (!btf->struct_ops_tab)
+		return NULL;
+
+	*ret_cnt = btf->struct_ops_tab->cnt;
+	return (const struct bpf_struct_ops_desc *)btf->struct_ops_tab->ops;
+}
+
+#endif /* CONFIG_BPF_JIT */