bpftool: Add recursive map dumping
Subsystems (4)
v6 cover bpftool: Add recursive map dumping
Add -r/--recursive to dump referenced inner maps after the selected roots, with deduplication and bounded descriptor use. The second patch checks output formats and operation under a low descriptor limit.
Changes in v6:
- Grow the pending inner-map ID array with libbpf_ensure_mem() instead of reallocating for every ID. Keep the existing bound on open descriptors.
- Check snprintf() failures and truncation before advancing the expected JSON buffer offset in the multiple-root selftest.
- Clarify the unused array-slot comment, name the large output buffer size, and shorten the selftest commit message.
The formatting check is defensive; I have not established the reported stack overflow in v5's fixed four-map fixture.
v5: https://lore.kernel.org/r/[email protected]
AI reviews:
https://lore.kernel.org/r/c55811f4eb2a0d4884ee2eb3167557cd405a5b7aecd988a51acf525c77e3a0e1@mail.kernel.org
https://lore.kernel.org/r/4fba1aedc906d6c5072a1ae9a72496e6d307abd60c456cb870077cf93cc8f4ce@mail.kernel.org
https://lore.kernel.org/r/[email protected]
Validation:
- Rebuilt bpftool and the focused selftest runner.
- All 12 bpftool_map_dump subtests passed, including the 64-inner-map cases under RLIMIT_NOFILE=32 and the multiple-root JSON check.
- Tested alongside the pending batch-dump series: all 23 selected subtests passed, with no skips or failures, in an x86-64 KVM guest running Linux 7.3.0-rc2 from bpf/master, using LLVM 20 BPF objects.
- Diff and bpftool synchronization checks passed; checkpatch reported no errors. The generated patches apply cleanly to current bpf-next.
This was a focused run. Unrelated selftests requiring unavailable kernel features were excluded from the build with PERMISSIVE=1.
Tianyi Chen (2):
bpftool: Add recursive map dumping selftests/bpf: Cover recursive bpftool map dumps
.../bpf/bpftool/Documentation/bpftool-map.rst | 22 +- tools/bpf/bpftool/bash-completion/bpftool | 2 +- tools/bpf/bpftool/main.c | 7 +- tools/bpf/bpftool/main.h | 1 + tools/bpf/bpftool/map.c | 130 ++++- .../bpf/prog_tests/bpftool_map_dump.c | 480 ++++++++++++++++++ 6 files changed, 631 insertions(+), 11 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/bpftool_map_dump.c
base-commit: af0b84a9215d951d16f26b7ee34353b970cf5d4e
Signature · 1 line
2.55.0
PATCH v6 1/2 bpftool: Add recursive map dumping
From: Tianyi Chen <[email protected]>
Dumping a map-of-maps currently shows inner map IDs without their contents. Add -r/--recursive to dump referenced inner maps as well, leaving the default output unchanged. Show the selected maps followed by distinct discovered inner maps, preserving plain and BTF formatting and using an array of map objects for JSON output.
Holding every discovered inner-map FD open would make descriptor use grow with the number of maps and could exhaust RLIMIT_NOFILE. Keep the selected map FDs open, queue distinct inner map IDs, and open, dump and close each queued map in turn. This needs only one additional map FD. The tradeoff is deferred ID resolution: concurrently removed inner maps can disappear before they are opened, so the dump is not atomic.
Report failure when an inner map cannot be opened, retain per-entry lookup errors, and close JSON containers before returning.
--- .../bpf/bpftool/Documentation/bpftool-map.rst | 22 ++- tools/bpf/bpftool/bash-completion/bpftool | 2 +- tools/bpf/bpftool/main.c | 7 +- tools/bpf/bpftool/main.h | 1 + tools/bpf/bpftool/map.c | 130 ++++++++++++++++-- 5 files changed, 151 insertions(+), 11 deletions(-)
tools/bpf/bpftool/Documentation/bpftool-map.rst +21 -1
@@ -16,7 +16,8 @@ SYNOPSIS **bpftool** [*OPTIONS*] **map** *COMMAND* -*OPTIONS* := { |COMMON_OPTIONS| | { **-f** | **--bpffs** } | { **-n** | **--nomount** } } +*OPTIONS* := { |COMMON_OPTIONS| | { **-f** | **--bpffs** } | +{ **-n** | **--nomount** } | { **-r** | **--recursive** } } *COMMANDS* := { **show** | **list** | **create** | **dump** | **update** | **lookup** | **getnext** |
@@ -170,6 +171,25 @@ OPTIONS Do not automatically attempt to mount any virtual file system (such as tracefs or BPF virtual file system) when necessary. +-r, --recursive + Also dump the inner maps referenced by **array_of_maps** and **hash_of_maps** + entries when running **map dump**. Each map ID is visited once, even if + several entries refer to it. Selected maps are followed by their inner maps. + + Plain output includes a header identifying each map. On success, JSON output + is always an array of map objects, each containing an **id** and an + **elements** array, including when only one map is dumped. Outer map entries + retain their **inner_map_id** field, which identifies the corresponding inner + map object. + + Inner map IDs are resolved when the maps are visited. The dump is not an + atomic snapshot: concurrent updates can change map contents or remove a + referenced inner map before it is visited. Failure to open a referenced + inner map stops the dump and returns a nonzero exit status. Output may + contain maps or entries printed before the error. + + In JSON mode, the enclosing arrays and objects are closed before returning. + EXAMPLES ======== **# bpftool map show**
tools/bpf/bpftool/bash-completion/bpftool +1 -1
@@ -261,7 +261,7 @@ _bpftool() # Deal with options if [[ ${words[cword]} == -* ]]; then - local c='--version --json --pretty --bpffs --mapcompat --debug \ + local c='--version --json --pretty --recursive --bpffs --mapcompat --debug \ --use-loader --base-btf --sign -i -k' COMPREPLY=( $( compgen -W "$c" -- "$cur" ) ) return 0
tools/bpf/bpftool/main.c +6 -1
@@ -26,6 +26,7 @@ static int (*last_do_help)(int argc, char **argv);json_writer_t *json_wtr;bool pretty_output;bool json_output; +bool recursive_dump;bool show_pinned;bool block_mount;bool verifier_logs;
@@ -456,6 +457,7 @@ int main(int argc, char **argv) { "json", no_argument, NULL, 'j' }, { "help", no_argument, NULL, 'h' }, { "pretty", no_argument, NULL, 'p' }, + { "recursive", no_argument, NULL, 'r' }, { "version", no_argument, NULL, 'V' }, { "bpffs", no_argument, NULL, 'f' }, { "mapcompat", no_argument, NULL, 'm' },
@@ -479,7 +481,7 @@ int main(int argc, char **argv) bin_name ="bpftool" ; opterr =0 ; -while ((opt =getopt_long (argc, argv,"VhpjfLmndSi:k:B:l" , +while ((opt =getopt_long (argc, argv,"VhpjrfLmndSi:k:B:l" , options,NULL )) >=0 ) {switch (opt) {case 'V' :
@@ -501,6 +503,9 @@ int main(int argc, char **argv) }jsonw_pretty (json_wtr, pretty_output);break ; +case 'r' : + recursive_dump = true; +break ;case 'f' : show_pinned = true;break ;
tools/bpf/bpftool/main.h +1 -0
@@ -83,6 +83,7 @@ extern const char *bin_name;extern json_writer_t *json_wtr;extern bool json_output; +extern bool recursive_dump;extern bool show_pinned;extern bool show_pids;extern bool block_mount;
tools/bpf/bpftool/map.c +122 -8
219 lines not on this page · raw message
Signature · 1 line
2.55.0
Quentin Monnet
maintainer2026-09-11 13:10 UTC+0800 ~ Tianyi Chen <[email protected]>
Quoted 15 lines
From: Tianyi Chen <[email protected]>
Dumping a map-of-maps currently shows inner map IDs without their contents. Add -r/--recursive to dump referenced inner maps as well, leaving the default output unchanged. Show the selected maps followed by distinct discovered inner maps, preserving plain and BTF formatting and using an array of map objects for JSON output.
Holding every discovered inner-map FD open would make descriptor use grow with the number of maps and could exhaust
RLIMIT_NOFILE. Keep the selected map FDs open, queue distinct inner map IDs, and open, dump and close each queued map in turn. This needs only one additional map FD. The tradeoff is deferred ID resolution: concurrently removed inner maps can disappear before they are opened, so the dump is not atomic.
Quoted 6 lines
Report failure when an inner map cannot be opened, retain per-entry lookup errors, and close JSON containers before returning.
Assisted-by LLMSigned-off-by Tianyi Chen <[email protected]>
Hi, and thanks for working on this!
Please find some comments below.
Quoted 13 lines
--- .../bpf/bpftool/Documentation/bpftool-map.rst | 22 ++- tools/bpf/bpftool/bash-completion/bpftool | 2 +- tools/bpf/bpftool/main.c | 7 +- tools/bpf/bpftool/main.h | 1 + tools/bpf/bpftool/map.c | 130 ++++++++++++++++-- 5 files changed, 151 insertions(+), 11 deletions(-)tools/bpf/bpftool/Documentation/bpftool-map.rst +0
-0
tools/bpf/bpftool/Documentation/bpftool-map.rst SYNOPSIS · line 20
Quoted 6 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +2
-1@@ -16,7 +16,8 @@ SYNOPSIS **bpftool** [*OPTIONS*] **map** *COMMAND* -*OPTIONS* := { |COMMON_OPTIONS| | { **-f** | **--bpffs** } | { **-n** | **--nomount** } } +*OPTIONS* := { |COMMON_OPTIONS| | { **-f** | **--bpffs** } | +{ **-n** | **--nomount** } | { **-r** | **--recursive** } }
Nitpick: I'd rather break the line after |COMMON_OPTIONS|, like in bpftool-prog.rst.
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 177
Quoted 11 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +4
-0*COMMANDS* := { **show** | **list** | **create** | **dump** | **update** | **lookup** | **getnext** |@@ -170,6 +171,25 @@ OPTIONS Do not automatically attempt to mount any virtual file system (such as tracefs or BPF virtual file system) when necessary. +-r, --recursive + Also dump the inner maps referenced by **array_of_maps** and **hash_of_maps** + entries when running **map dump**. Each map ID is visited once, even if + several entries refer to it. Selected maps are followed by their inner maps.
OK
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 183
Quoted 6 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +6
-0+ + Plain output includes a header identifying each map. On success, JSON output + is always an array of map objects, each containing an **id** and an + **elements** array, including when only one map is dumped. Outer map entries + retain their **inner_map_id** field, which identifies the corresponding inner + map object.
I'm not sure we need such a detailed description of the output format in the man page. Please remove.
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 189
Quoted 6 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +6
-0+ + Inner map IDs are resolved when the maps are visited. The dump is not an + atomic snapshot: concurrent updates can change map contents or remove a + referenced inner map before it is visited. Failure to open a referenced + inner map stops the dump and returns a nonzero exit status. Output may + contain maps or entries printed before the error.
Same thing, I'm not sure this is necessary. Maybe just keep the first half (the note about the maps susceptible to change during the dump).
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 191
Quoted 2 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +2
-0+ + In JSON mode, the enclosing arrays and objects are closed before returning.
Let's get rid of this, please.
Quoted 30 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +1
-0+ EXAMPLES ======== **# bpftool map show**tools/bpf/bpftool/bash-completion/bpftool +1
-1@@ -261,7 +261,7 @@ _bpftool() # Deal with options if [[ ${words[cword]} == -* ]]; then - local c='--version --json --pretty --bpffs --mapcompat --debug \ + local c='--version --json --pretty --recursive --bpffs --mapcompat --debug \ --use-loader --base-btf --sign -i -k' COMPREPLY=( $( compgen -W "$c" -- "$cur" ) ) return 0tools/bpf/bpftool/main.c +1
-0@@ -26,6 +26,7 @@ static int (*last_do_help)(int argc, char **argv);json_writer_t *json_wtr;bool pretty_output;bool json_output; +bool recursive_dump;bool show_pinned;bool block_mount;bool verifier_logs;
tools/bpf/bpftool/main.c int main(int argc, char **argv) · line 460
Quoted 4 lines
tools/bpf/bpftool/main.c +1
-0@@ -456,6 +457,7 @@ int main(int argc, char **argv) { "json", no_argument, NULL, 'j' }, { "help", no_argument, NULL, 'h' }, { "pretty", no_argument, NULL, 'p' }, + { "recursive", no_argument, NULL, 'r' },
The "recursive" option that you add is specific to a single subcommand for "bpftool map". It's true that some other options behave in a similar way, but overall, bpftool tends to use dash-options when it affects the generic behaviour (perfect example: JSON flags), and keywords otherwise. In the current case, given that we don't really have an equivalent use for "recursive" for the other commands, I'd keep it a keyword:
bpftool map dump id 1337 recursive
Could you change it, please?
The code itself looks good to me, thanks for working on this!
Quentin
Hi Quentin,
Quoted 1 line
break the line after |COMMON_OPTIONS|
Done.
Quoted 1 line
I'm not sure we need such a detailed description of the output format
Removed the detailed output/error descriptions and JSON-container note. The man page now describes recursion and the non-atomic traversal.
Quoted 1 line
bpftool map dump id 1337 recursive
Changed to this keyword syntax, with per-invocation state and matching help, completion and selftests. The global -r/--recursive options are gone.
Sent v7 as a new thread:
https://lore.kernel.org/r/[email protected]
All 13 map-dump subtests pass. I also checked pinned maps, per-CPU inner maps and keyword scope across batch commands after rebasing onto current bpf-next.
Thanks,
Tianyi
Quoted 138 lines · Quentin Monnet
2026-09-11 13:10 UTC+0800 ~ Tianyi Chen <[email protected]>
Quoted 15 lines
From: Tianyi Chen <[email protected]>
Dumping a map-of-maps currently shows inner map IDs without their contents. Add -r/--recursive to dump referenced inner maps as well, leaving the default output unchanged. Show the selected maps followed by distinct discovered inner maps, preserving plain and BTF formatting and using an array of map objects for JSON output.
Holding every discovered inner-map FD open would make descriptor use grow with the number of maps and could exhaust
RLIMIT_NOFILE. Keep the selected map FDs open, queue distinct inner map IDs, and open, dump and close each queued map in turn. This needs only one additional map FD. The tradeoff is deferred ID resolution: concurrently removed inner maps can disappear before they are opened, so the dump is not atomic.Quoted 6 lines
Report failure when an inner map cannot be opened, retain per-entry lookup errors, and close JSON containers before returning.
Assisted-by LLMSigned-off-by Tianyi Chen <[email protected]>Hi, and thanks for working on this!
Please find some comments below.
Quoted 13 lines
--- .../bpf/bpftool/Documentation/bpftool-map.rst | 22 ++- tools/bpf/bpftool/bash-completion/bpftool | 2 +- tools/bpf/bpftool/main.c | 7 +- tools/bpf/bpftool/main.h | 1 + tools/bpf/bpftool/map.c | 130 ++++++++++++++++-- 5 files changed, 151 insertions(+), 11 deletions(-)tools/bpf/bpftool/Documentation/bpftool-map.rst +0
-0tools/bpf/bpftool/Documentation/bpftool-map.rst SYNOPSIS · line 20
Quoted 6 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +2
-1@@ -16,7 +16,8 @@ SYNOPSIS **bpftool** [*OPTIONS*] **map** *COMMAND* -*OPTIONS* := { |COMMON_OPTIONS| | { **-f** | **--bpffs** } | { **-n** | **--nomount** } } +*OPTIONS* := { |COMMON_OPTIONS| | { **-f** | **--bpffs** } | +{ **-n** | **--nomount** } | { **-r** | **--recursive** } }Nitpick: I'd rather break the line after |COMMON_OPTIONS|, like in
bpftool-prog.rst.tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 177
Quoted 11 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +4
-0*COMMANDS* := { **show** | **list** | **create** | **dump** | **update** | **lookup** | **getnext** |@@ -170,6 +171,25 @@ OPTIONS Do not automatically attempt to mount any virtual file system (such as tracefs or BPF virtual file system) when necessary. +-r, --recursive + Also dump the inner maps referenced by **array_of_maps** and **hash_of_maps** + entries when running **map dump**. Each map ID is visited once, even if + several entries refer to it. Selected maps are followed by their inner maps.OK
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 183
Quoted 6 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +6
-0+ + Plain output includes a header identifying each map. On success, JSON output + is always an array of map objects, each containing an **id** and an + **elements** array, including when only one map is dumped. Outer map entries + retain their **inner_map_id** field, which identifies the corresponding inner + map object.I'm not sure we need such a detailed description of the output format in the man page. Please remove.
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 189
Quoted 6 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +6
-0+ + Inner map IDs are resolved when the maps are visited. The dump is not an + atomic snapshot: concurrent updates can change map contents or remove a + referenced inner map before it is visited. Failure to open a referenced + inner map stops the dump and returns a nonzero exit status. Output may + contain maps or entries printed before the error.Same thing, I'm not sure this is necessary. Maybe just keep the first half (the note about the maps susceptible to change during the dump).
tools/bpf/bpftool/Documentation/bpftool-map.rst OPTIONS · line 191
Quoted 2 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +2
-0+ + In JSON mode, the enclosing arrays and objects are closed before returning.Let's get rid of this, please.
Quoted 30 lines
tools/bpf/bpftool/Documentation/bpftool-map.rst +1
-0+ EXAMPLES ======== **# bpftool map show**tools/bpf/bpftool/bash-completion/bpftool +1
-1@@ -261,7 +261,7 @@ _bpftool() # Deal with options if [[ ${words[cword]} == -* ]]; then - local c='--version --json --pretty --bpffs --mapcompat --debug \ + local c='--version --json --pretty --recursive --bpffs --mapcompat --debug \ --use-loader --base-btf --sign -i -k' COMPREPLY=( $( compgen -W "$c" -- "$cur" ) ) return 0tools/bpf/bpftool/main.c +1
-0@@ -26,6 +26,7 @@ static int (*last_do_help)(int argc, char **argv);json_writer_t *json_wtr;bool pretty_output;bool json_output; +bool recursive_dump;bool show_pinned;bool block_mount;bool verifier_logs;tools/bpf/bpftool/main.c int main(int argc, char **argv) · line 460
Quoted 4 lines
tools/bpf/bpftool/main.c +1
-0@@ -456,6 +457,7 @@ int main(int argc, char **argv) { "json", no_argument, NULL, 'j' }, { "help", no_argument, NULL, 'h' }, { "pretty", no_argument, NULL, 'p' }, + { "recursive", no_argument, NULL, 'r' },The "recursive" option that you add is specific to a single subcommand for "bpftool map". It's true that some other options behave in a similar way, but overall, bpftool tends to use dash-options when it affects the generic behaviour (perfect example: JSON flags), and keywords otherwise. In the current case, given that we don't really have an equivalent use for "recursive" for the other commands, I'd keep it a keyword:
bpftool map dump id 1337 recursive
Could you change it, please?
The code itself looks good to me, thanks for working on this!
Quentin
PATCH v6 2/2 selftests/bpf: Cover recursive bpftool map dumps
In reply to Tianyi ChenFrom: Tianyi Chen <[email protected]>
Exercise array-of-maps and hash-of-maps dumps with shared inner maps, empty maps, BTF values and multiple selected roots. Check complete JSON documents, plain output, root ordering, deduplication, both option forms and unchanged nonrecursive output.
Cover ordinary and nested perf event arrays to preserve unsupported lookup error markers. Dump 64 distinct inner maps under RLIMIT_NOFILE=32 to detect retaining a descriptor for every inner map. Check JSON and plain output, and ensure child descriptor cleanup leaves the parent's resources usable.
--- .../bpf/prog_tests/bpftool_map_dump.c | 480 ++++++++++++++++++ 1 file changed, 480 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/bpftool_map_dump.c
tools/testing/selftests/bpf/prog_tests/bpftool_map_dump.c new file +480 -0
@@ -0,0 +1,480 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include <test_progs.h> +#include <bpftool_helpers.h> +#include <bpf/btf.h> +#include <sys/resource.h> +#include <dirent.h> + +#define OUTPUT_SIZE 8192 +#define MANY_MAPS_OUTPUT_SIZE 65536 + +static bool dump_map (__u32 id,const char *options,char *output) +{ +char command[MAX_BPFTOOL_CMD_LEN ]; + +snprintf (command,sizeof (command),"%s map dump id %u" , options, id); +memset (output,0 ,OUTPUT_SIZE ); +if (!ASSERT_OK (get_bpftool_command_output (command, output,OUTPUT_SIZE -1 ), +"dump_map" )) +return false; +/* The helper leaves the trailing newline in place. */ + output[strcspn (output,"\n" )] ='\0' ; +return true; +} + +static __u32 map_id (int fd) +{ +struct bpf_map_info info = {}; +__u32 len =sizeof (info); + +if (!ASSERT_OK (bpf_map_get_info_by_fd (fd, &info, &len),"map_info" )) +return 0 ; +return info.id; +} + +static int count_token (const char *output,const char *token) +{ +int count =0 ; + +while ((output =strstr (output, token))) { + count++; + output +=strlen (token); + } +return count; +} + +static void check_plain (__u32 root_id,__u32 inner_id,const char *type, +int entries,bool typed) +{ +char command[MAX_BPFTOOL_CMD_LEN ], header[128 ]; +char output[OUTPUT_SIZE ] = {}; +const char *root, *inner; + +snprintf (command,sizeof (command),"--recursive map dump id %u" , root_id); +if (!ASSERT_OK (get_bpftool_command_output (command, output,sizeof (output) -1 ), +"plain_dump" )) +return ; +snprintf (header,sizeof (header),"%u: %s name dump_outer " , root_id, type); + root =strstr (output, header); +if (!ASSERT_OK_PTR (root,"plain_root_header" )) +return ; +ASSERT_EQ (root - output,0 ,"plain_root_first" ); +ASSERT_EQ (count_token (output,"inner_map_id:" ), entries,"plain_references" ); +if (entries) { +snprintf (header,sizeof (header),"%u: hash name dump_inner " , inner_id); + inner =strstr (output, header); +if (ASSERT_OK_PTR (inner,"plain_inner_header" )) +ASSERT_GT (inner - root,0 ,"plain_inner_after_root" ); +ASSERT_EQ (count_token (output, header),1 ,"plain_inner_once" ); + } +ASSERT_EQ (count_token (output,"Found " ), entries && !typed ?2 :1 , +"plain_map_count" ); +if (typed) { +ASSERT_HAS_SUBSTR (output,"\"key\": 0" ,"plain_btf_key" ); +ASSERT_HAS_SUBSTR (output,"\"value\": 16843009" ,"plain_btf_value" ); + } +} + +static void test_outer (enum bpf_map_type type,int entries,bool empty_inner, +bool typed) +{ +LIBBPF_OPTS (bpf_map_create_opts, opts); +LIBBPF_OPTS (bpf_map_create_opts, inner_opts); +struct btf *btf =NULL ; +char outer[OUTPUT_SIZE ], inner[OUTPUT_SIZE ], output[OUTPUT_SIZE ]; +char expected[OUTPUT_SIZE *3 ], reference[64 ]; +const char *type_name =libbpf_bpf_map_type_str (type); +int inner_fd =-1 , outer_fd =-1 ; +__u32 root_id, inner_id, key, value =0x01010101 ; + +if (typed) { + btf =btf__new_empty (); +if (!ASSERT_OK_PTR (btf,"create_btf" ) || + !ASSERT_EQ (btf__add_int (btf,"unsigned int" ,4 ,0 ),1 ,"btf_int" ) || + !ASSERT_OK (btf__load_into_kernel (btf),"load_btf" )) + goto out; + inner_opts.btf_fd =btf__fd (btf); + inner_opts.btf_key_type_id =1 ; + inner_opts.btf_value_type_id =1 ; + } + inner_fd =bpf_map_create (BPF_MAP_TYPE_HASH ,"dump_inner" ,sizeof (key), +sizeof (value),2 , &inner_opts); +if (!ASSERT_OK_FD (inner_fd,"create_inner" )) + goto out; + key =0 ; +if (!empty_inner && + !ASSERT_OK (bpf_map_update_elem (inner_fd, &key, &value,BPF_ANY ), +"populate_inner" )) + goto out; + opts.inner_map_fd = inner_fd; + outer_fd =bpf_map_create (type,"dump_outer" ,sizeof (key),sizeof (__u32), +3 , &opts); +if (!ASSERT_OK_FD (outer_fd,"create_outer" )) + goto out; +/* For arrays, unused slots also exercise failed lookups. */ +for (key =0 ; key < entries; key++) +if (!ASSERT_OK (bpf_map_update_elem (outer_fd, &key, &inner_fd,BPF_ANY ), +"populate_outer" )) + goto out; + root_id =map_id (outer_fd); + inner_id =map_id (inner_fd); +if (!root_id || !inner_id || !dump_map (root_id,"-j" , outer) || + !dump_map (inner_id,"-j" , inner)) + goto out; + +ASSERT_EQ (outer[0 ],'[' ,"default_array" ); +ASSERT_EQ (count_token (outer,"\"elements\":" ),0 ,"default_no_wrapper" ); +ASSERT_EQ (count_token (outer,"\"id\":" ),0 ,"default_no_header" ); +snprintf (reference,sizeof (reference),"\"inner_map_id\":%u" , inner_id); +ASSERT_EQ (count_token (outer, reference), entries,"default_references" ); +if (!entries) +ASSERT_STREQ (outer,"[]" ,"empty_outer_default" ); +if (empty_inner) +ASSERT_STREQ (inner,"[]" ,"empty_inner_default" ); +else if (typed) +ASSERT_HAS_SUBSTR (inner,"\"formatted\":{\"key\":0,\"value\":16843009}" , +"typed_inner" ); +else +ASSERT_STREQ (inner, +"[{\"key\":[\"0x00\",\"0x00\",\"0x00\",\"0x00\"]," +"\"value\":[\"0x01\",\"0x01\",\"0x01\",\"0x01\"]}]" , +"ordinary_default" ); + +/* +* Compare the complete JSON document: a flat array with the root first, +* one copy of the shared inner map, and unchanged entry representations. +*/ +if (entries) +snprintf (expected,sizeof (expected), +"[{\"id\":%u,\"type\":\"%s\",\"name\":\"dump_outer\"," +"\"flags\":0,\"elements\":%s},{\"id\":%u,\"type\":\"hash\"," +"\"name\":\"dump_inner\",\"flags\":0,\"elements\":%s}]" , + root_id, type_name, outer, inner_id, inner); +else +snprintf (expected,sizeof (expected), +"[{\"id\":%u,\"type\":\"%s\",\"name\":\"dump_outer\"," +"\"flags\":0,\"elements\":[]}]" , root_id, type_name); +if (dump_map (root_id,"-j -r" , output)) +ASSERT_STREQ (output, expected,"recursive_json" ); +if (dump_map (root_id,"--json --recursive" , output)) +ASSERT_STREQ (output, expected,"recursive_long_options" ); +check_plain (root_id, inner_id, type_name, entries, typed); + +/* Recursion on an ordinary map still emits a single map object. */ +snprintf (expected,sizeof (expected), +"[{\"id\":%u,\"type\":\"hash\",\"name\":\"dump_inner\"," +"\"flags\":0,\"elements\":%s}]" , inner_id, inner); +if (dump_map (inner_id,"-j -r" , output)) +ASSERT_STREQ (output, expected,"ordinary_recursive" ); +out: +if (outer_fd >=0 ) +close (outer_fd); +if (inner_fd >=0 ) +close (inner_fd); +btf__free (btf); +} + +static void test_multiple_roots (void ) +{ +LIBBPF_OPTS (bpf_map_create_opts, opts); +char command[MAX_BPFTOOL_CMD_LEN ], name[BPF_OBJ_NAME_LEN ]; +char output[OUTPUT_SIZE ] = {}, expected[OUTPUT_SIZE *4 ], elements[OUTPUT_SIZE ]; +static const char *const types[] = {"hash" ,"array_of_maps" ,"hash_of_maps" ,"hash" }; +int fds[] = {-1 ,-1 ,-1 ,-1 }; +__u32 ids[4 ], key; +size_t len =0 ; +int i, n; + +/* +* Select the first inner map and both outers as roots. The other inner +* map must be appended after all three roots, even though it is found +* while dumping the first outer. A process-specific name avoids other +* tests' maps joining the selection. +*/ +snprintf (name,sizeof (name),"dump_%u" ,getpid ()); + fds[0 ] =bpf_map_create (BPF_MAP_TYPE_HASH , name,4 ,4 ,1 ,NULL ); +if (!ASSERT_OK_FD (fds[0 ],"create_selected_inner" )) + goto out; + fds[3 ] =bpf_map_create (BPF_MAP_TYPE_HASH ,"dump_discovered" ,4 ,4 ,1 ,NULL ); +if (!ASSERT_OK_FD (fds[3 ],"create_discovered_inner" )) + goto out; + opts.inner_map_fd = fds[0 ]; + fds[1 ] =bpf_map_create (BPF_MAP_TYPE_ARRAY_OF_MAPS , name,4 ,4 ,2 , &opts); +if (!ASSERT_OK_FD (fds[1 ],"create_array_root" )) + goto out; + fds[2 ] =bpf_map_create (BPF_MAP_TYPE_HASH_OF_MAPS , name,4 ,4 ,2 , &opts); +if (!ASSERT_OK_FD (fds[2 ],"create_hash_root" )) + goto out; +for (i =1 ; i <=2 ; i++) { + key =0 ; +if (!ASSERT_OK (bpf_map_update_elem (fds[i], &key, &fds[0 ],BPF_ANY ), +"reference_selected_inner" )) + goto out; + key =1 ; +if (!ASSERT_OK (bpf_map_update_elem (fds[i], &key, &fds[3 ],BPF_ANY ), +"reference_discovered_inner" )) + goto out; + } +for (i =0 ; i <ARRAY_SIZE (fds); i++) { + ids[i] =map_id (fds[i]); +if (!ids[i] || !dump_map (ids[i],"-j" , elements)) + goto out; + n =snprintf (expected + len,sizeof (expected) - len, +"%s{\"id\":%u,\"type\":\"%s\",\"name\":\"%s\"," +"\"flags\":0,\"elements\":%s}%s" , + i ?"," :"[" , ids[i], types[i], + i ==3 ?"dump_discovered" : name, elements, i ==3 ?"]" :"" ); +if (!ASSERT_GE (n,0 ,"format_expected" ) || + !ASSERT_LT (n,sizeof (expected) - len,"expected_length" )) + goto out; + len += n; + } +snprintf (command,sizeof (command),"-j -r map dump name %s" , name); +if (ASSERT_OK (get_bpftool_command_output (command, output,sizeof (output) -1 ), +"dump_multiple_roots" )) { + output[strcspn (output,"\n" )] ='\0' ; +ASSERT_STREQ (output, expected,"roots_first_and_seed_dedup" ); + } +out: +for (i =0 ; i <ARRAY_SIZE (fds); i++) +if (fds[i] >=0 ) +close (fds[i]); +} + +static void test_unreadable (bool outer) +{ +LIBBPF_OPTS (bpf_map_create_opts, opts); +char elements[OUTPUT_SIZE ], output[OUTPUT_SIZE ], root[OUTPUT_SIZE ]; +char expected[OUTPUT_SIZE *3 ], plain[OUTPUT_SIZE ] = {}; +char command[MAX_BPFTOOL_CMD_LEN ]; +int inner_fd =-1 , outer_fd =-1 , lookup_errno; +__u32 inner_id, root_id, key =0 , value; + +/* +* Every key is enumerable, but PERF_EVENT_ARRAY lookup returns +* ENOTSUPP (the kernel-internal errno). Check both entries so an +* early exit on the first lookup failure cannot pass. +*/ + inner_fd =bpf_map_create (BPF_MAP_TYPE_PERF_EVENT_ARRAY ,"dump_unreadable" , +sizeof (key),sizeof (value),2 ,NULL ); +if (!ASSERT_OK_FD (inner_fd,"create_unreadable" )) + goto out; +if (!ASSERT_LT (bpf_map_lookup_elem (inner_fd, &key, &value),0 , +"unreadable_lookup" )) + goto out; + lookup_errno = errno; +if (!ASSERT_NEQ (lookup_errno,ENOENT ,"unreadable_not_missing" )) + goto out; + inner_id =map_id (inner_fd); +if (!inner_id || !dump_map (inner_id,"-j" , elements)) + goto out; +ASSERT_EQ (count_token (elements,"\"error\":" ),2 ,"default_json_errors" ); +snprintf (command,sizeof (command),"map dump id %u" , inner_id); +if (!ASSERT_OK (get_bpftool_command_output (command, plain,sizeof (plain) -1 ), +"default_plain_unreadable" )) + goto out; +ASSERT_EQ (count_token (plain,strerror (lookup_errno)),2 ,"default_plain_errors" ); +ASSERT_HAS_SUBSTR (plain,"Found 0 elements" ,"default_plain_count" ); + + root_id = inner_id; +if (outer) { + opts.inner_map_fd = inner_fd; + outer_fd =bpf_map_create (BPF_MAP_TYPE_ARRAY_OF_MAPS ,"dump_outer" , +sizeof (key),sizeof (value),1 , &opts); +if (!ASSERT_OK_FD (outer_fd,"create_outer" ) || + !ASSERT_OK (bpf_map_update_elem (outer_fd, &key, &inner_fd,BPF_ANY ), +"populate_outer" )) + goto out; + root_id =map_id (outer_fd); +if (!root_id || !dump_map (root_id,"-j" , root)) + goto out; +snprintf (expected,sizeof (expected), +"[{\"id\":%u,\"type\":\"array_of_maps\",\"name\":\"dump_outer\"," +"\"flags\":0,\"elements\":%s},{\"id\":%u," +"\"type\":\"perf_event_array\",\"name\":\"dump_unreadable\"," +"\"flags\":0,\"elements\":%s}]" , root_id, root, inner_id, elements); + }else { +snprintf (expected,sizeof (expected), +"[{\"id\":%u,\"type\":\"perf_event_array\"," +"\"name\":\"dump_unreadable\",\"flags\":0,\"elements\":%s}]" , + inner_id, elements); + } +if (dump_map (root_id,"-j -r" , output)) +ASSERT_STREQ (output, expected,"recursive_unreadable_json" ); +memset (output,0 ,sizeof (output)); +snprintf (command,sizeof (command),"-r map dump id %u" , root_id); +if (ASSERT_OK (get_bpftool_command_output (command, output,sizeof (output) -1 ), +"recursive_unreadable_plain" )) { +ASSERT_HAS_SUBSTR (output, plain,"recursive_plain_preserves_errors" ); +ASSERT_EQ (count_token (output,strerror (lookup_errno)),2 , +"recursive_plain_errors" ); +ASSERT_EQ (count_token (output,"Found " ), outer ?2 :1 , +"recursive_plain_maps" ); + } +out: +if (outer_fd >=0 ) +close (outer_fd); +if (inner_fd >=0 ) +close (inner_fd); +} + +static void test_many_inner_maps (bool json) +{ +enum { +DUMP_OK , +DUMP_ERR_RLIMIT , +DUMP_ERR_COMMAND , +DUMP_ERR_COUNTS , +DUMP_ERR_IDS , +DUMP_ERR_JSON , +DUMP_ERR_FDS , + }; +LIBBPF_OPTS (bpf_map_create_opts, opts); +const struct rlimit limit = { .rlim_cur =32 , .rlim_max =32 }; +char command[MAX_BPFTOOL_CMD_LEN ], token[64 ]; +__u32 ids[64 ], root_id, key; +int inner_fd =-1 , outer_fd =-1 , status; +int inherited_fds[32 ], nr_inherited =0 , i; +char *output =NULL ; +pid_t pid; + + inner_fd =bpf_map_create (BPF_MAP_TYPE_HASH ,"dump_inner" ,4 ,4 ,1 ,NULL ); +if (!ASSERT_OK_FD (inner_fd,"create_template" )) + goto out; + opts.inner_map_fd = inner_fd; + outer_fd =bpf_map_create (BPF_MAP_TYPE_ARRAY_OF_MAPS ,"dump_outer" ,4 ,4 , +ARRAY_SIZE (ids), &opts); +close (inner_fd); + inner_fd =-1 ; +if (!ASSERT_OK_FD (outer_fd,"create_outer" )) + goto out; +for (key =0 ; key <ARRAY_SIZE (ids); key++) { + inner_fd =bpf_map_create (BPF_MAP_TYPE_HASH ,"dump_inner" ,4 ,4 ,1 ,NULL ); +if (!ASSERT_OK_FD (inner_fd,"create_inner" ) || + !ASSERT_OK (bpf_map_update_elem (outer_fd, &key, &inner_fd,BPF_ANY ), +"populate_outer" )) + goto out; + ids[key] =map_id (inner_fd); +if (!ids[key]) + goto out; +/* The outer map keeps each distinct inner map alive. */ +close (inner_fd); + inner_fd =-1 ; + } + root_id =map_id (outer_fd); + output =calloc (1 ,MANY_MAPS_OUTPUT_SIZE ); +if (!root_id || !ASSERT_OK_PTR (output,"allocate_output" )) + goto out; + +/* Fill the low FD slots to exercise inherited descriptor cleanup. */ +for (i =0 ; i <ARRAY_SIZE (inherited_fds); i++) { +int fd =open ("/dev/null" ,O_RDONLY ); + +if (!ASSERT_OK_FD (fd,"open_inherited_fd" )) + goto out; + inherited_fds[nr_inherited++] = fd; + } + +/* +* Create all fixtures before lowering the limit, and keep the test +* runner's limit unchanged. Retaining every discovered FD would exceed +* this limit before the recursive dump could visit all inner maps. +*/ + pid =fork (); +if (!ASSERT_GE (pid,0 ,"fork" )) + goto out; +if (!pid) { +struct dirent *entry; +DIR *dir; + +/* Reserve a slot for the directory even if the parent is full. */ +close (inherited_fds[nr_inherited -1 ]); + dir =opendir ("/proc/self/fd" ); +if (!dir) +_exit (DUMP_ERR_FDS ); +/* The parent keeps the outer map and its inner maps alive. */ +for (;;) { +char *end; +long fd; + + errno =0 ; + entry =readdir (dir); +if (!entry) { +if (errno) +_exit (DUMP_ERR_FDS ); +break ; + } + fd =strtol (entry->d_name, &end,10 ); +if (*end || fd <3 || fd ==dirfd (dir)) +continue ; +close (fd); + } +if (closedir (dir)) +_exit (DUMP_ERR_FDS ); +if (setrlimit (RLIMIT_NOFILE , &limit)) +_exit (DUMP_ERR_RLIMIT ); +snprintf (command,sizeof (command),"%s -r map dump id %u" , + json ?"-j" :"" , root_id); +if (get_bpftool_command_output (command, output,MANY_MAPS_OUTPUT_SIZE -1 )) +_exit (DUMP_ERR_COMMAND ); +if (count_token (output, json ?"\"id\":" :"Found " ) !=ARRAY_SIZE (ids) +1 || +count_token (output, json ?"\"inner_map_id\":" :"inner_map_id:" ) != +ARRAY_SIZE (ids)) +_exit (DUMP_ERR_COUNTS ); +for (key =0 ; key <ARRAY_SIZE (ids); key++) { +if (json) +snprintf (token,sizeof (token),"\"id\":%u," , ids[key]); +else +snprintf (token,sizeof (token),"\n%u: hash name dump_inner " , + ids[key]); +if (count_token (output, token) !=1 ) +_exit (DUMP_ERR_IDS ); + } +if (json && (output[0 ] !='[' || +strcmp (output +strlen (output) -2 ,"]\n" ))) +_exit (DUMP_ERR_JSON ); +_exit (DUMP_OK ); + } +if (ASSERT_EQ (waitpid (pid, &status,0 ), pid,"waitpid" ) && +ASSERT_TRUE (WIFEXITED (status),"child_exited" )) +ASSERT_EQ (WEXITSTATUS (status),DUMP_OK ,"dump_with_low_fd_limit" ); +for (i =0 ; i < nr_inherited; i++) +ASSERT_GE (fcntl (inherited_fds[i],F_GETFD ),0 ,"parent_fd_preserved" ); +ASSERT_EQ (map_id (outer_fd), root_id,"parent_outer_preserved" ); +out: +while (nr_inherited) +close (inherited_fds[--nr_inherited]); +free (output); +if (outer_fd >=0 ) +close (outer_fd); +if (inner_fd >=0 ) +close (inner_fd); +} + +void test_bpftool_map_dump (void ) +{ +if (test__start_subtest ("unreadable_ordinary" )) +test_unreadable (false); +if (test__start_subtest ("unreadable_inner" )) +test_unreadable (true); +if (test__start_subtest ("many_inner_maps_json" )) +test_many_inner_maps (true); +if (test__start_subtest ("many_inner_maps_plain" )) +test_many_inner_maps (false); +if (test__start_subtest ("multiple_roots" )) +test_multiple_roots (); +if (test__start_subtest ("array_of_maps" )) +test_outer (BPF_MAP_TYPE_ARRAY_OF_MAPS ,1 , false, false); +if (test__start_subtest ("hash_of_maps" )) +test_outer (BPF_MAP_TYPE_HASH_OF_MAPS ,1 , false, false); +if (test__start_subtest ("shared_inner" )) +test_outer (BPF_MAP_TYPE_ARRAY_OF_MAPS ,2 , false, false); +if (test__start_subtest ("empty_array_of_maps" )) +test_outer (BPF_MAP_TYPE_ARRAY_OF_MAPS ,0 , false, false); +if (test__start_subtest ("empty_hash_of_maps" )) +test_outer (BPF_MAP_TYPE_HASH_OF_MAPS ,0 , false, false); +if (test__start_subtest ("btf_inner" )) +test_outer (BPF_MAP_TYPE_HASH_OF_MAPS ,1 , false, true); +if (test__start_subtest ("empty_inner" )) +test_outer (BPF_MAP_TYPE_HASH_OF_MAPS ,1 , true, false); +}
Signature · 1 line
2.55.0