236 lines
7.8 KiB
C
236 lines
7.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */
|
|
#include <errno.h>
|
|
#include <sys/syscall.h>
|
|
#include <unistd.h>
|
|
#include "test_global_map_resize.skel.h"
|
|
#include "test_progs.h"
|
|
|
|
static void run_prog_bss_array_sum(void)
|
|
{
|
|
(void)syscall(__NR_getpid);
|
|
}
|
|
|
|
static void run_prog_data_array_sum(void)
|
|
{
|
|
(void)syscall(__NR_getuid);
|
|
}
|
|
|
|
static void global_map_resize_bss_subtest(void)
|
|
{
|
|
int err;
|
|
struct test_global_map_resize *skel;
|
|
struct bpf_map *map;
|
|
const __u32 desired_sz = sizeof(skel->bss->sum) + sysconf(_SC_PAGE_SIZE) * 2;
|
|
size_t array_len, actual_sz, new_sz;
|
|
|
|
skel = test_global_map_resize__open();
|
|
if (!ASSERT_OK_PTR(skel, "test_global_map_resize__open"))
|
|
goto teardown;
|
|
|
|
/* set some initial value before resizing.
|
|
* it is expected this non-zero value will be preserved
|
|
* while resizing.
|
|
*/
|
|
skel->bss->array[0] = 1;
|
|
|
|
/* resize map value and verify the new size */
|
|
map = skel->maps.bss;
|
|
err = bpf_map__set_value_size(map, desired_sz);
|
|
if (!ASSERT_OK(err, "bpf_map__set_value_size"))
|
|
goto teardown;
|
|
if (!ASSERT_EQ(bpf_map__value_size(map), desired_sz, "resize"))
|
|
goto teardown;
|
|
|
|
new_sz = sizeof(skel->data_percpu_arr->percpu_arr[0]) * libbpf_num_possible_cpus();
|
|
err = bpf_map__set_value_size(skel->maps.data_percpu_arr, new_sz);
|
|
ASSERT_OK(err, "percpu_arr_resize");
|
|
|
|
/* set the expected number of elements based on the resized array */
|
|
array_len = (desired_sz - sizeof(skel->bss->sum)) / sizeof(skel->bss->array[0]);
|
|
if (!ASSERT_GT(array_len, 1, "array_len"))
|
|
goto teardown;
|
|
|
|
skel->bss = bpf_map__initial_value(skel->maps.bss, &actual_sz);
|
|
if (!ASSERT_OK_PTR(skel->bss, "bpf_map__initial_value (ptr)"))
|
|
goto teardown;
|
|
if (!ASSERT_EQ(actual_sz, desired_sz, "bpf_map__initial_value (size)"))
|
|
goto teardown;
|
|
|
|
/* fill the newly resized array with ones,
|
|
* skipping the first element which was previously set
|
|
*/
|
|
for (int i = 1; i < array_len; i++)
|
|
skel->bss->array[i] = 1;
|
|
|
|
/* set global const values before loading */
|
|
skel->rodata->pid = getpid();
|
|
skel->rodata->bss_array_len = array_len;
|
|
skel->rodata->data_array_len = 1;
|
|
|
|
err = test_global_map_resize__load(skel);
|
|
if (!ASSERT_OK(err, "test_global_map_resize__load"))
|
|
goto teardown;
|
|
err = test_global_map_resize__attach(skel);
|
|
if (!ASSERT_OK(err, "test_global_map_resize__attach"))
|
|
goto teardown;
|
|
|
|
/* run the bpf program which will sum the contents of the array.
|
|
* since the array was filled with ones,verify the sum equals array_len
|
|
*/
|
|
run_prog_bss_array_sum();
|
|
if (!ASSERT_EQ(skel->bss->sum, array_len, "sum"))
|
|
goto teardown;
|
|
|
|
teardown:
|
|
test_global_map_resize__destroy(skel);
|
|
}
|
|
|
|
static void global_map_resize_data_subtest(void)
|
|
{
|
|
struct test_global_map_resize *skel;
|
|
struct bpf_map *map;
|
|
const __u32 desired_sz = sysconf(_SC_PAGE_SIZE) * 2;
|
|
size_t array_len, actual_sz, new_sz;
|
|
int err;
|
|
|
|
skel = test_global_map_resize__open();
|
|
if (!ASSERT_OK_PTR(skel, "test_global_map_resize__open"))
|
|
goto teardown;
|
|
|
|
/* set some initial value before resizing.
|
|
* it is expected this non-zero value will be preserved
|
|
* while resizing.
|
|
*/
|
|
skel->data_custom->my_array[0] = 1;
|
|
|
|
/* resize map value and verify the new size */
|
|
map = skel->maps.data_custom;
|
|
err = bpf_map__set_value_size(map, desired_sz);
|
|
if (!ASSERT_OK(err, "bpf_map__set_value_size"))
|
|
goto teardown;
|
|
if (!ASSERT_EQ(bpf_map__value_size(map), desired_sz, "resize"))
|
|
goto teardown;
|
|
|
|
new_sz = sizeof(skel->data_percpu_arr->percpu_arr[0]) * libbpf_num_possible_cpus();
|
|
err = bpf_map__set_value_size(skel->maps.data_percpu_arr, new_sz);
|
|
ASSERT_OK(err, "percpu_arr_resize");
|
|
|
|
/* set the expected number of elements based on the resized array */
|
|
array_len = (desired_sz - sizeof(skel->bss->sum)) / sizeof(skel->data_custom->my_array[0]);
|
|
if (!ASSERT_GT(array_len, 1, "array_len"))
|
|
goto teardown;
|
|
|
|
skel->data_custom = bpf_map__initial_value(skel->maps.data_custom, &actual_sz);
|
|
if (!ASSERT_OK_PTR(skel->data_custom, "bpf_map__initial_value (ptr)"))
|
|
goto teardown;
|
|
if (!ASSERT_EQ(actual_sz, desired_sz, "bpf_map__initial_value (size)"))
|
|
goto teardown;
|
|
|
|
/* fill the newly resized array with ones,
|
|
* skipping the first element which was previously set
|
|
*/
|
|
for (int i = 1; i < array_len; i++)
|
|
skel->data_custom->my_array[i] = 1;
|
|
|
|
/* set global const values before loading */
|
|
skel->rodata->pid = getpid();
|
|
skel->rodata->bss_array_len = 1;
|
|
skel->rodata->data_array_len = array_len;
|
|
|
|
err = test_global_map_resize__load(skel);
|
|
if (!ASSERT_OK(err, "test_global_map_resize__load"))
|
|
goto teardown;
|
|
err = test_global_map_resize__attach(skel);
|
|
if (!ASSERT_OK(err, "test_global_map_resize__attach"))
|
|
goto teardown;
|
|
|
|
/* run the bpf program which will sum the contents of the array.
|
|
* since the array was filled with ones,verify the sum equals array_len
|
|
*/
|
|
run_prog_data_array_sum();
|
|
if (!ASSERT_EQ(skel->bss->sum, array_len, "sum"))
|
|
goto teardown;
|
|
|
|
teardown:
|
|
test_global_map_resize__destroy(skel);
|
|
}
|
|
|
|
static void global_map_resize_invalid_subtest(void)
|
|
{
|
|
int err;
|
|
struct test_global_map_resize *skel;
|
|
struct bpf_map *map;
|
|
__u32 element_sz, desired_sz;
|
|
|
|
skel = test_global_map_resize__open();
|
|
if (!ASSERT_OK_PTR(skel, "test_global_map_resize__open"))
|
|
return;
|
|
|
|
/* attempt to resize a global datasec map to size
|
|
* which does NOT align with array
|
|
*/
|
|
map = skel->maps.data_custom;
|
|
if (!ASSERT_NEQ(bpf_map__btf_value_type_id(map), 0, ".data.custom initial btf"))
|
|
goto teardown;
|
|
/* set desired size a fraction of element size beyond an aligned size */
|
|
element_sz = sizeof(skel->data_custom->my_array[0]);
|
|
desired_sz = element_sz + element_sz / 2;
|
|
/* confirm desired size does NOT align with array */
|
|
if (!ASSERT_NEQ(desired_sz % element_sz, 0, "my_array alignment"))
|
|
goto teardown;
|
|
err = bpf_map__set_value_size(map, desired_sz);
|
|
/* confirm resize is OK but BTF info is cleared */
|
|
if (!ASSERT_OK(err, ".data.custom bpf_map__set_value_size") ||
|
|
!ASSERT_EQ(bpf_map__btf_key_type_id(map), 0, ".data.custom clear btf key") ||
|
|
!ASSERT_EQ(bpf_map__btf_value_type_id(map), 0, ".data.custom clear btf val"))
|
|
goto teardown;
|
|
|
|
/* attempt to resize a global datasec map whose only var is NOT an array */
|
|
map = skel->maps.data_non_array;
|
|
if (!ASSERT_NEQ(bpf_map__btf_value_type_id(map), 0, ".data.non_array initial btf"))
|
|
goto teardown;
|
|
/* set desired size to arbitrary value */
|
|
desired_sz = 1024;
|
|
err = bpf_map__set_value_size(map, desired_sz);
|
|
/* confirm resize is OK but BTF info is cleared */
|
|
if (!ASSERT_OK(err, ".data.non_array bpf_map__set_value_size") ||
|
|
!ASSERT_EQ(bpf_map__btf_key_type_id(map), 0, ".data.non_array clear btf key") ||
|
|
!ASSERT_EQ(bpf_map__btf_value_type_id(map), 0, ".data.non_array clear btf val"))
|
|
goto teardown;
|
|
|
|
/* attempt to resize a global datasec map
|
|
* whose last var is NOT an array
|
|
*/
|
|
map = skel->maps.data_array_not_last;
|
|
if (!ASSERT_NEQ(bpf_map__btf_value_type_id(map), 0, ".data.array_not_last initial btf"))
|
|
goto teardown;
|
|
/* set desired size to a multiple of element size */
|
|
element_sz = sizeof(skel->data_array_not_last->my_array_first[0]);
|
|
desired_sz = element_sz * 8;
|
|
/* confirm desired size aligns with array */
|
|
if (!ASSERT_EQ(desired_sz % element_sz, 0, "my_array_first alignment"))
|
|
goto teardown;
|
|
err = bpf_map__set_value_size(map, desired_sz);
|
|
/* confirm resize is OK but BTF info is cleared */
|
|
if (!ASSERT_OK(err, ".data.array_not_last bpf_map__set_value_size") ||
|
|
!ASSERT_EQ(bpf_map__btf_key_type_id(map), 0, ".data.array_not_last clear btf key") ||
|
|
!ASSERT_EQ(bpf_map__btf_value_type_id(map), 0, ".data.array_not_last clear btf val"))
|
|
goto teardown;
|
|
|
|
teardown:
|
|
test_global_map_resize__destroy(skel);
|
|
}
|
|
|
|
void test_global_map_resize(void)
|
|
{
|
|
if (test__start_subtest("global_map_resize_bss"))
|
|
global_map_resize_bss_subtest();
|
|
|
|
if (test__start_subtest("global_map_resize_data"))
|
|
global_map_resize_data_subtest();
|
|
|
|
if (test__start_subtest("global_map_resize_invalid"))
|
|
global_map_resize_invalid_subtest();
|
|
}
|