mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-08-05 16:54:27 +00:00
selftests/bpf: Implement setting global variables in veristat
To better verify some complex BPF programs we'd like to preset global
variables.
This patch introduces CLI argument `--set-global-vars` or `-G` to
veristat, that allows presetting values to global variables defined
in BPF program. For example:
prog.c:
```
enum Enum { ELEMENT1 = 0, ELEMENT2 = 5 };
const volatile __s64 a = 5;
const volatile __u8 b = 5;
const volatile enum Enum c = ELEMENT2;
const volatile bool d = false;
char arr[4] = {0};
SEC("tp_btf/sched_switch")
int BPF_PROG(...)
{
bpf_printk("%c\n", arr[a]);
bpf_printk("%c\n", arr[b]);
bpf_printk("%c\n", arr[c]);
bpf_printk("%c\n", arr[d]);
return 0;
}
```
By default verification of the program fails:
```
./veristat prog.bpf.o
```
By presetting global variables, we can make verification pass:
```
./veristat wq.bpf.o -G "a = 0" -G "b = 1" -G "c = 2" -G "d = 3"
```
Signed-off-by: Mykyta Yatsenko <yatsenko@meta.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Acked-by: Eduard Zingerman <eddyz87@gmail.com>
Link: https://lore.kernel.org/bpf/20250225163101.121043-2-mykyta.yatsenko5@gmail.com
This commit is contained in:
Mykyta Yatsenko
Andrii Nakryiko
parent
0ba0ef012e
commit
e3c9abd0d1
1 changed files with 300 additions and 1 deletions
|
|
@ -3,6 +3,7 @@
|
|||
#define _GNU_SOURCE
|
||||
#include <argp.h>
|
||||
#include <libgen.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <sched.h>
|
||||
|
|
@ -154,6 +155,16 @@ struct filter {
|
|||
bool abs;
|
||||
};
|
||||
|
||||
struct var_preset {
|
||||
char *name;
|
||||
enum { INTEGRAL, ENUMERATOR } type;
|
||||
union {
|
||||
long long ivalue;
|
||||
char *svalue;
|
||||
};
|
||||
bool applied;
|
||||
};
|
||||
|
||||
static struct env {
|
||||
char **filenames;
|
||||
int filename_cnt;
|
||||
|
|
@ -195,6 +206,8 @@ static struct env {
|
|||
int progs_processed;
|
||||
int progs_skipped;
|
||||
int top_src_lines;
|
||||
struct var_preset *presets;
|
||||
int npresets;
|
||||
} env;
|
||||
|
||||
static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
|
||||
|
|
@ -246,12 +259,15 @@ static const struct argp_option opts[] = {
|
|||
{ "test-reg-invariants", 'r', NULL, 0,
|
||||
"Force BPF verifier failure on register invariant violation (BPF_F_TEST_REG_INVARIANTS program flag)" },
|
||||
{ "top-src-lines", 'S', "N", 0, "Emit N most frequent source code lines" },
|
||||
{ "set-global-vars", 'G', "GLOBAL", 0, "Set global variables provided in the expression, for example \"var1 = 1\"" },
|
||||
{},
|
||||
};
|
||||
|
||||
static int parse_stats(const char *stats_str, struct stat_specs *specs);
|
||||
static int append_filter(struct filter **filters, int *cnt, const char *str);
|
||||
static int append_filter_file(const char *path);
|
||||
static int append_var_preset(struct var_preset **presets, int *cnt, const char *expr);
|
||||
static int append_var_preset_file(const char *filename);
|
||||
|
||||
static error_t parse_arg(int key, char *arg, struct argp_state *state)
|
||||
{
|
||||
|
|
@ -353,6 +369,17 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state)
|
|||
argp_usage(state);
|
||||
}
|
||||
break;
|
||||
case 'G': {
|
||||
if (arg[0] == '@')
|
||||
err = append_var_preset_file(arg + 1);
|
||||
else
|
||||
err = append_var_preset(&env.presets, &env.npresets, arg);
|
||||
if (err) {
|
||||
fprintf(stderr, "Failed to parse global variable presets: %s\n", arg);
|
||||
return err;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ARGP_KEY_ARG:
|
||||
tmp = realloc(env.filenames, (env.filename_cnt + 1) * sizeof(*env.filenames));
|
||||
if (!tmp)
|
||||
|
|
@ -632,7 +659,7 @@ static int append_filter_file(const char *path)
|
|||
f = fopen(path, "r");
|
||||
if (!f) {
|
||||
err = -errno;
|
||||
fprintf(stderr, "Failed to open filters in '%s': %d\n", path, err);
|
||||
fprintf(stderr, "Failed to open filters in '%s': %s\n", path, strerror(err));
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -1292,6 +1319,261 @@ static int process_prog(const char *filename, struct bpf_object *obj, struct bpf
|
|||
return 0;
|
||||
};
|
||||
|
||||
static int append_var_preset(struct var_preset **presets, int *cnt, const char *expr)
|
||||
{
|
||||
void *tmp;
|
||||
struct var_preset *cur;
|
||||
char var[256], val[256], *val_end;
|
||||
long long value;
|
||||
int n;
|
||||
|
||||
tmp = realloc(*presets, (*cnt + 1) * sizeof(**presets));
|
||||
if (!tmp)
|
||||
return -ENOMEM;
|
||||
*presets = tmp;
|
||||
cur = &(*presets)[*cnt];
|
||||
memset(cur, 0, sizeof(*cur));
|
||||
(*cnt)++;
|
||||
|
||||
if (sscanf(expr, "%s = %s %n", var, val, &n) != 2 || n != strlen(expr)) {
|
||||
fprintf(stderr, "Failed to parse expression '%s'\n", expr);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (val[0] == '-' || isdigit(val[0])) {
|
||||
/* must be a number */
|
||||
errno = 0;
|
||||
value = strtoll(val, &val_end, 0);
|
||||
if (errno == ERANGE) {
|
||||
errno = 0;
|
||||
value = strtoull(val, &val_end, 0);
|
||||
}
|
||||
if (errno || *val_end != '\0') {
|
||||
fprintf(stderr, "Failed to parse value '%s'\n", val);
|
||||
return -EINVAL;
|
||||
}
|
||||
cur->ivalue = value;
|
||||
cur->type = INTEGRAL;
|
||||
} else {
|
||||
/* if not a number, consider it enum value */
|
||||
cur->svalue = strdup(val);
|
||||
if (!cur->svalue)
|
||||
return -ENOMEM;
|
||||
cur->type = ENUMERATOR;
|
||||
}
|
||||
|
||||
cur->name = strdup(var);
|
||||
if (!cur->name)
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int append_var_preset_file(const char *filename)
|
||||
{
|
||||
char buf[1024];
|
||||
FILE *f;
|
||||
int err = 0;
|
||||
|
||||
f = fopen(filename, "rt");
|
||||
if (!f) {
|
||||
err = -errno;
|
||||
fprintf(stderr, "Failed to open presets in '%s': %s\n", filename, strerror(err));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
while (fscanf(f, " %1023[^\n]\n", buf) == 1) {
|
||||
if (buf[0] == '\0' || buf[0] == '#')
|
||||
continue;
|
||||
|
||||
err = append_var_preset(&env.presets, &env.npresets, buf);
|
||||
if (err)
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
fclose(f);
|
||||
return err;
|
||||
}
|
||||
|
||||
static bool is_signed_type(const struct btf_type *t)
|
||||
{
|
||||
if (btf_is_int(t))
|
||||
return btf_int_encoding(t) & BTF_INT_SIGNED;
|
||||
if (btf_is_any_enum(t))
|
||||
return btf_kflag(t);
|
||||
return true;
|
||||
}
|
||||
|
||||
static int enum_value_from_name(const struct btf *btf, const struct btf_type *t,
|
||||
const char *evalue, long long *retval)
|
||||
{
|
||||
if (btf_is_enum(t)) {
|
||||
struct btf_enum *e = btf_enum(t);
|
||||
int i, n = btf_vlen(t);
|
||||
|
||||
for (i = 0; i < n; ++i, ++e) {
|
||||
const char *cur_name = btf__name_by_offset(btf, e->name_off);
|
||||
|
||||
if (strcmp(cur_name, evalue) == 0) {
|
||||
*retval = e->val;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
} else if (btf_is_enum64(t)) {
|
||||
struct btf_enum64 *e = btf_enum64(t);
|
||||
int i, n = btf_vlen(t);
|
||||
|
||||
for (i = 0; i < n; ++i, ++e) {
|
||||
const char *cur_name = btf__name_by_offset(btf, e->name_off);
|
||||
__u64 value = btf_enum64_value(e);
|
||||
|
||||
if (strcmp(cur_name, evalue) == 0) {
|
||||
*retval = value;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static bool is_preset_supported(const struct btf_type *t)
|
||||
{
|
||||
return btf_is_int(t) || btf_is_enum(t) || btf_is_enum64(t);
|
||||
}
|
||||
|
||||
static int set_global_var(struct bpf_object *obj, struct btf *btf, const struct btf_type *t,
|
||||
struct bpf_map *map, struct btf_var_secinfo *sinfo,
|
||||
struct var_preset *preset)
|
||||
{
|
||||
const struct btf_type *base_type;
|
||||
void *ptr;
|
||||
long long value = preset->ivalue;
|
||||
size_t size;
|
||||
|
||||
base_type = btf__type_by_id(btf, btf__resolve_type(btf, t->type));
|
||||
if (!base_type) {
|
||||
fprintf(stderr, "Failed to resolve type %d\n", t->type);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (!is_preset_supported(base_type)) {
|
||||
fprintf(stderr, "Setting value for type %s is not supported\n",
|
||||
btf__name_by_offset(btf, base_type->name_off));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (preset->type == ENUMERATOR) {
|
||||
if (btf_is_any_enum(base_type)) {
|
||||
if (enum_value_from_name(btf, base_type, preset->svalue, &value)) {
|
||||
fprintf(stderr,
|
||||
"Failed to find integer value for enum element %s\n",
|
||||
preset->svalue);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "Value %s is not supported for type %s\n",
|
||||
preset->svalue, btf__name_by_offset(btf, base_type->name_off));
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check if value fits into the target variable size */
|
||||
if (sinfo->size < sizeof(value)) {
|
||||
bool is_signed = is_signed_type(base_type);
|
||||
__u32 unsigned_bits = sinfo->size * 8 - (is_signed ? 1 : 0);
|
||||
long long max_val = 1ll << unsigned_bits;
|
||||
|
||||
if (value >= max_val || value < -max_val) {
|
||||
fprintf(stderr,
|
||||
"Variable %s value %lld is out of range [%lld; %lld]\n",
|
||||
btf__name_by_offset(btf, t->name_off), value,
|
||||
is_signed ? -max_val : 0, max_val - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
ptr = bpf_map__initial_value(map, &size);
|
||||
if (!ptr || sinfo->offset + sinfo->size > size)
|
||||
return -EINVAL;
|
||||
|
||||
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
|
||||
memcpy(ptr + sinfo->offset, &value, sinfo->size);
|
||||
} else { /* __BYTE_ORDER == __BIG_ENDIAN */
|
||||
__u8 src_offset = sizeof(value) - sinfo->size;
|
||||
|
||||
memcpy(ptr + sinfo->offset, (void *)&value + src_offset, sinfo->size);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_global_vars(struct bpf_object *obj, struct var_preset *presets, int npresets)
|
||||
{
|
||||
struct btf_var_secinfo *sinfo;
|
||||
const char *sec_name;
|
||||
const struct btf_type *t;
|
||||
struct bpf_map *map;
|
||||
struct btf *btf;
|
||||
int i, j, k, n, cnt, err = 0;
|
||||
|
||||
if (npresets == 0)
|
||||
return 0;
|
||||
|
||||
btf = bpf_object__btf(obj);
|
||||
if (!btf)
|
||||
return -EINVAL;
|
||||
|
||||
cnt = btf__type_cnt(btf);
|
||||
for (i = 1; i != cnt; ++i) {
|
||||
t = btf__type_by_id(btf, i);
|
||||
|
||||
if (!btf_is_datasec(t))
|
||||
continue;
|
||||
|
||||
sinfo = btf_var_secinfos(t);
|
||||
sec_name = btf__name_by_offset(btf, t->name_off);
|
||||
map = bpf_object__find_map_by_name(obj, sec_name);
|
||||
if (!map)
|
||||
continue;
|
||||
|
||||
n = btf_vlen(t);
|
||||
for (j = 0; j < n; ++j, ++sinfo) {
|
||||
const struct btf_type *var_type = btf__type_by_id(btf, sinfo->type);
|
||||
const char *var_name;
|
||||
|
||||
if (!btf_is_var(var_type))
|
||||
continue;
|
||||
|
||||
var_name = btf__name_by_offset(btf, var_type->name_off);
|
||||
|
||||
for (k = 0; k < npresets; ++k) {
|
||||
if (strcmp(var_name, presets[k].name) != 0)
|
||||
continue;
|
||||
|
||||
if (presets[k].applied) {
|
||||
fprintf(stderr, "Variable %s is set more than once",
|
||||
var_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
err = set_global_var(obj, btf, var_type, map, sinfo, presets + k);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
presets[k].applied = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 0; i < npresets; ++i) {
|
||||
if (!presets[i].applied) {
|
||||
fprintf(stderr, "Global variable preset %s has not been applied\n",
|
||||
presets[i].name);
|
||||
}
|
||||
presets[i].applied = false;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
static int process_obj(const char *filename)
|
||||
{
|
||||
const char *base_filename = basename(strdupa(filename));
|
||||
|
|
@ -1341,6 +1623,11 @@ static int process_obj(const char *filename)
|
|||
if (prog_cnt == 1) {
|
||||
prog = bpf_object__next_program(obj, NULL);
|
||||
bpf_program__set_autoload(prog, true);
|
||||
err = set_global_vars(obj, env.presets, env.npresets);
|
||||
if (err) {
|
||||
fprintf(stderr, "Failed to set global variables %d\n", err);
|
||||
goto cleanup;
|
||||
}
|
||||
process_prog(filename, obj, prog);
|
||||
goto cleanup;
|
||||
}
|
||||
|
|
@ -1355,6 +1642,12 @@ static int process_obj(const char *filename)
|
|||
goto cleanup;
|
||||
}
|
||||
|
||||
err = set_global_vars(tobj, env.presets, env.npresets);
|
||||
if (err) {
|
||||
fprintf(stderr, "Failed to set global variables %d\n", err);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
lprog = NULL;
|
||||
bpf_object__for_each_program(tprog, tobj) {
|
||||
const char *tprog_name = bpf_program__name(tprog);
|
||||
|
|
@ -2460,5 +2753,11 @@ int main(int argc, char **argv)
|
|||
free(env.deny_filters[i].prog_glob);
|
||||
}
|
||||
free(env.deny_filters);
|
||||
for (i = 0; i < env.npresets; ++i) {
|
||||
free(env.presets[i].name);
|
||||
if (env.presets[i].type == ENUMERATOR)
|
||||
free(env.presets[i].svalue);
|
||||
}
|
||||
free(env.presets);
|
||||
return -err;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue