Skip to contentSkip to conversation

bpftool: cast pointers for shadow types explicitly.

PATCH Applied Kui-Feng Lee 6 participants 10 messages Mar 12, 2024 – Mar 14, 2024

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 bpftool: cast pointers for shadow types explicitly.

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
 tools/bpf/bpftool/gen.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tools/bpf/bpftool/gen.c +1 -1
index 4fa4ade1ce74..dedafea0c127 100644
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
 			continue;
 		codegen("\
 			\n\
-				obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+				obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
 			\n\
 			", ident);
 	}
Signature · 1 line
2.34.1
#2 lore raw

2024-03-12 05:22 UTC+0000 ~ Yonghong Song <[email protected]>

Quoted 7 lines · Kui-Feng Lee
Quoted 5 lines

According to a report, skeletons fail to assign shadow pointers when being
compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

Quoted 9 lines
Quoted 4 lines

To support C++, we do explicit casting for each shadow pointer.

LGTM.

Thanks!

#3 lore raw
In reply to Kui-Feng Lee
Quoted 18 lines · Kui-Feng Lee

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
 tools/bpf/bpftool/gen.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tools/bpf/bpftool/gen.c +0 -0
index 4fa4ade1ce74..dedafea0c127 100644

tools/bpf/bpftool/gen.c static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj) · line 1134

Quoted 5 lines
tools/bpf/bpftool/gen.c +1 -1
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
                        continue;
                codegen("\
                        \n\
-                               obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+                               obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\

Given we have a named struct type for this and we use explicit type names in other parts of generated skeleton code, let's maybe use "struct %s__%s__%s" explicitly here (passing in obj_name, ident, type_name)?

No strong preferences, but feels like a consistent approach here would be nice.

Quoted 6 lines
tools/bpf/bpftool/gen.c +0 -1
                        \n\
                        ", ident);
        }
--

2.34.1

#4 lore raw
Quoted 14 lines · Andrii Nakryiko
Quoted 13 lines · Kui-Feng Lee

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
  tools/bpf/bpftool/gen.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
Quoted 15 lines

tools/bpf/bpftool/gen.c static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj) · line 1134

Quoted 10 lines
tools/bpf/bpftool/gen.c +1 -1
index 4fa4ade1ce74..dedafea0c127 100644
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
                         continue;
                 codegen("\
                         \n\
-                               obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+                               obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\

Given we have a named struct type for this and we use explicit type names in other parts of generated skeleton code, let's maybe use "struct %s__%s__%s" explicitly here (passing in obj_name, ident, type_name)?

I have considered about this solution. But, C++ works differently. It has nested namespaces. That means it should be referred as "XXX_skeleton::OOO_st_ops_map" in C++. Then, we need #if #else #endif directives to provide two separated casting.

Quoted 9 lines

No strong preferences, but feels like a consistent approach here would be nice.

Quoted 6 lines
tools/bpf/bpftool/gen.c +0 -1
                         \n\
                         ", ident);
         }
--

2.34.1

#5 lore raw
Quoted 34 lines · Kui-Feng Lee
Quoted 14 lines · Andrii Nakryiko
Quoted 13 lines · Kui-Feng Lee

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
  tools/bpf/bpftool/gen.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
Quoted 15 lines

tools/bpf/bpftool/gen.c static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj) · line 1134

Quoted 10 lines
tools/bpf/bpftool/gen.c +1 -1
index 4fa4ade1ce74..dedafea0c127 100644
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
                         continue;
                 codegen("\
                         \n\
-                               obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+                               obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\

Given we have a named struct type for this and we use explicit type names in other parts of generated skeleton code, let's maybe use "struct %s__%s__%s" explicitly here (passing in obj_name, ident, type_name)?

Quoted 5 lines

I have considered about this solution. But, C++ works differently. It has nested namespaces. That means it should be referred as "XXX_skeleton::OOO_st_ops_map" in C++. Then, we need #if #else #endif directives to provide two separated casting.

we cast to (struct <skeleton> *) by name of the skeleton, so it should be fine, I don't see why we'd need to do something C++ specific here

Quoted 9 lines
Quoted 9 lines

No strong preferences, but feels like a consistent approach here would be nice.

Quoted 6 lines
tools/bpf/bpftool/gen.c +0 -1
                         \n\
                         ", ident);
         }
--

2.34.1

#6 lore raw
Quoted 35 lines · Andrii Nakryiko
Quoted 34 lines · Kui-Feng Lee
Quoted 29 lines · Andrii Nakryiko
Quoted 18 lines · Kui-Feng Lee

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
   tools/bpf/bpftool/gen.c | 2 +-
   1 file changed, 1 insertion(+), 1 deletion(-)
tools/bpf/bpftool/gen.c +0 -0
index 4fa4ade1ce74..dedafea0c127 100644

tools/bpf/bpftool/gen.c static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj) · line 1134

Quoted 5 lines
tools/bpf/bpftool/gen.c +1 -1
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
                          continue;
                  codegen("\
                          \n\
-                               obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+                               obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\

Given we have a named struct type for this and we use explicit type names in other parts of generated skeleton code, let's maybe use "struct %s__%s__%s" explicitly here (passing in obj_name, ident, type_name)?

Quoted 8 lines
Quoted 5 lines

I have considered about this solution. But, C++ works differently. It has nested namespaces. That means it should be referred as "XXX_skeleton::OOO_st_ops_map" in C++. Then, we need #if #else #endif directives to provide two separated casting.

we cast to (struct <skeleton> *) by name of the skeleton, so it should be fine, I don't see why we'd need to do something C++ specific here

The skeleton looks like

struct struct_ops_module {
    ......
    struct {
        struct 
struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed {
            ....
        } testmod_zeroed;
    } struct_ops;
};

struct struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed is inside of struct struct_ops_module. In C++, it should be referred as "struct_ops_module::struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed".

The other option is moving definitions of these types to the top scope.

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines

No strong preferences, but feels like a consistent approach here would be nice.

Quoted 6 lines
tools/bpf/bpftool/gen.c +0 -1
                          \n\
                          ", ident);
          }
--

2.34.1

#7 lore raw
Quoted 60 lines · Kui-Feng Lee
Quoted 35 lines · Andrii Nakryiko
Quoted 34 lines · Kui-Feng Lee
Quoted 29 lines · Andrii Nakryiko
Quoted 18 lines · Kui-Feng Lee

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
   tools/bpf/bpftool/gen.c | 2 +-
   1 file changed, 1 insertion(+), 1 deletion(-)
tools/bpf/bpftool/gen.c +0 -0
index 4fa4ade1ce74..dedafea0c127 100644

tools/bpf/bpftool/gen.c static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj) · line 1134

Quoted 5 lines
tools/bpf/bpftool/gen.c +1 -1
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
                          continue;
                  codegen("\
                          \n\
-                               obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+                               obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\

Given we have a named struct type for this and we use explicit type names in other parts of generated skeleton code, let's maybe use "struct %s__%s__%s" explicitly here (passing in obj_name, ident, type_name)?

Quoted 8 lines
Quoted 5 lines

I have considered about this solution. But, C++ works differently. It has nested namespaces. That means it should be referred as "XXX_skeleton::OOO_st_ops_map" in C++. Then, we need #if #else #endif directives to provide two separated casting.

we cast to (struct <skeleton> *) by name of the skeleton, so it should be fine, I don't see why we'd need to do something C++ specific here

The skeleton looks like

struct struct_ops_module {
     ......
     struct {
         struct
struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed {
             ....
         } testmod_zeroed;
     } struct_ops;
};
Quoted 3 lines

struct struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed is inside of struct struct_ops_module. In C++, it should be referred as "struct_ops_module::struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed".

ah, makes sense, thanks for elaborating

Quoted 2 lines

The other option is moving definitions of these types to the top scope.

no, it's fine the way you did it in this patch, I'll land it once bpf-next tree is open for new patches, thanks

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

No strong preferences, but feels like a consistent approach here would be nice.

Quoted 6 lines
tools/bpf/bpftool/gen.c +0 -1
                          \n\
                          ", ident);
          }
--

2.34.1

#8 lore raw
Quoted 66 lines · Andrii Nakryiko
Quoted 60 lines · Kui-Feng Lee
Quoted 35 lines · Andrii Nakryiko
Quoted 34 lines · Kui-Feng Lee
Quoted 29 lines · Andrii Nakryiko
Quoted 18 lines · Kui-Feng Lee

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

---
   tools/bpf/bpftool/gen.c | 2 +-
   1 file changed, 1 insertion(+), 1 deletion(-)
tools/bpf/bpftool/gen.c +0 -0
index 4fa4ade1ce74..dedafea0c127 100644

tools/bpf/bpftool/gen.c static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj) · line 1134

Quoted 5 lines
tools/bpf/bpftool/gen.c +1 -1
@@ -1131,7 +1131,7 @@ static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
                          continue;
                  codegen("\
                          \n\
-                               obj->struct_ops.%1$s = bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+                               obj->struct_ops.%1$s = (typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\

Given we have a named struct type for this and we use explicit type names in other parts of generated skeleton code, let's maybe use "struct %s__%s__%s" explicitly here (passing in obj_name, ident, type_name)?

Quoted 8 lines
Quoted 5 lines

I have considered about this solution. But, C++ works differently. It has nested namespaces. That means it should be referred as "XXX_skeleton::OOO_st_ops_map" in C++. Then, we need #if #else #endif directives to provide two separated casting.

we cast to (struct <skeleton> *) by name of the skeleton, so it should be fine, I don't see why we'd need to do something C++ specific here

The skeleton looks like

struct struct_ops_module {
     ......
     struct {
         struct
struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed {
             ....
         } testmod_zeroed;
     } struct_ops;
};
Quoted 3 lines

struct struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed is inside of struct struct_ops_module. In C++, it should be referred as "struct_ops_module::struct_ops_module__testmod_zeroed__bpf_testmod_ops___zeroed".

Quoted 8 lines

ah, makes sense, thanks for elaborating

Quoted 2 lines

The other option is moving definitions of these types to the top scope.

no, it's fine the way you did it in this patch, I'll land it once bpf-next tree is open for new patches, thanks

so I made the following changes/additions as I was applying your patch:

tools/bpf/bpftool/gen.c +0 -0
index dedafea0c127..3ce277544c24 100644
@@ -1131,7 +1131,8 @@ static void gen_st_ops_shadow_init(struct btf

*btf, struct bpf_object *obj)

                        continue;
                codegen("\
                        \n\

- obj->struct_ops.%1$s =
(typeof(obj->struct_ops.%1$s))bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
+ obj->struct_ops.%1$s =
(typeof(obj->struct_ops.%1$s))\n\
+

bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
                        \n\
                        ", ident);
        }
(quoted diff) +0 -0

b/tools/testing/selftests/bpf/test_cpp.cpp
index f4936834f76f..dde0bb16e782 100644

tools/testing/selftests/bpf/test_cpp.cpp +5 -0
@@ -7,6 +7,7 @@
 #include <bpf/bpf.h>
 #include <bpf/btf.h>
 #include "test_core_extern.skel.h"
+#include "struct_ops_module.skel.h"
 
 template <typename T>
 class Skeleton {
@@ -98,6 +99,7 @@ int main(int argc, char *argv[])
 {
        struct btf_dump_opts opts = { };
        struct test_core_extern *skel;
+       struct struct_ops_module *skel2;
        struct btf *btf;
        int fd;
 
@@ -118,6 +120,9 @@ int main(int argc, char *argv[])
        skel = test_core_extern__open_and_load();
        test_core_extern__destroy(skel);
 
+       skel2 = struct_ops_module__open_and_load();
+       struct_ops_module__destroy(skel2);
+
        fd = bpf_enable_stats(BPF_STATS_RUN_TIME);
        if (fd < 0)
                std::cout << "FAILED to enable stats: " << fd << std::endl;

test_cpp is a good think to validate that skeletons are compiled with C++ compiler just fine, so I referenced struct_ops-based skeleton there.

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

No strong preferences, but feels like a consistent approach here would be nice.

Quoted 6 lines
tools/bpf/bpftool/gen.c +0 -1
                          \n\
                          ", ident);
          }
--

2.34.1

#9 lore raw
In reply to Kui-Feng Lee
This patch was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:

Hello:

This patch was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:

Quoted 10 lines · On Mon, 11 Mar 2024 18:37:26 -0700 you wrote:

According to a report, skeletons fail to assign shadow pointers when being compiled with C++ programs. Unlike C doing implicit casting for void pointers, C++ requires an explicit casting.

To support C++, we do explicit casting for each shadow pointer.

[...]

Here is the summary with links:
- [bpf-next] bpftool: cast pointers for shadow types explicitly.

    https://git.kernel.org/bpf/bpf-next/c/c2a0257c1edf

You are awesome, thank you!

Signature · 2 lines
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html