mirror of
https://github.com/torvalds/linux.git
synced 2026-06-03 20:14:06 +02:00
selftests/bpf: Support array presets in veristat
Implement support for presetting values for array elements in veristat. For example: ``` sudo ./veristat set_global_vars.bpf.o -G "arr[3] = 1" ``` Arrays of structures and structure of arrays work, but each individual scalar value has to be set separately: `foo[1].bar[2] = value`. 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/20250625165904.87820-3-mykyta.yatsenko5@gmail.com
This commit is contained in:
Mykyta Yatsenko
Andrii Nakryiko
parent
be898cb5cb
commit
edc99d0b02
|
|
@ -165,7 +165,11 @@ struct rvalue {
|
|||
};
|
||||
|
||||
struct field_access {
|
||||
char *name;
|
||||
enum { FIELD_NAME, ARRAY_INDEX } type;
|
||||
union {
|
||||
char *name;
|
||||
struct rvalue index;
|
||||
};
|
||||
};
|
||||
|
||||
struct var_preset {
|
||||
|
|
@ -1630,28 +1634,60 @@ static int process_prog(const char *filename, struct bpf_object *obj, struct bpf
|
|||
free(buf);
|
||||
|
||||
return 0;
|
||||
};
|
||||
}
|
||||
|
||||
static int append_preset_atom(struct var_preset *preset, char *value, bool is_index)
|
||||
{
|
||||
struct field_access *tmp;
|
||||
int i = preset->atom_count;
|
||||
int err;
|
||||
|
||||
tmp = reallocarray(preset->atoms, i + 1, sizeof(*preset->atoms));
|
||||
if (!tmp)
|
||||
return -ENOMEM;
|
||||
|
||||
preset->atoms = tmp;
|
||||
preset->atom_count++;
|
||||
|
||||
if (is_index) {
|
||||
preset->atoms[i].type = ARRAY_INDEX;
|
||||
err = parse_rvalue(value, &preset->atoms[i].index);
|
||||
if (err)
|
||||
return err;
|
||||
} else {
|
||||
preset->atoms[i].type = FIELD_NAME;
|
||||
preset->atoms[i].name = strdup(value);
|
||||
if (!preset->atoms[i].name)
|
||||
return -ENOMEM;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_var_atoms(const char *full_var, struct var_preset *preset)
|
||||
{
|
||||
char expr[256], *name, *saveptr;
|
||||
char expr[256], var[256], *name, *saveptr;
|
||||
int n, len, off;
|
||||
|
||||
snprintf(expr, sizeof(expr), "%s", full_var);
|
||||
preset->atom_count = 0;
|
||||
while ((name = strtok_r(preset->atom_count ? NULL : expr, ".", &saveptr))) {
|
||||
struct field_access *tmp;
|
||||
int i = preset->atom_count;
|
||||
len = strlen(name);
|
||||
/* parse variable name */
|
||||
if (sscanf(name, "%[a-zA-Z0-9_] %n", var, &off) != 1) {
|
||||
fprintf(stderr, "Can't parse %s\n", name);
|
||||
return -EINVAL;
|
||||
}
|
||||
append_preset_atom(preset, var, false);
|
||||
|
||||
tmp = reallocarray(preset->atoms, i + 1, sizeof(*preset->atoms));
|
||||
if (!tmp)
|
||||
return -ENOMEM;
|
||||
|
||||
preset->atoms = tmp;
|
||||
preset->atom_count++;
|
||||
|
||||
preset->atoms[i].name = strdup(name);
|
||||
if (!preset->atoms[i].name)
|
||||
return -ENOMEM;
|
||||
/* parse optional array indexes */
|
||||
while (off < len) {
|
||||
if (sscanf(name + off, " [ %[a-zA-Z0-9_] ] %n", var, &n) != 1) {
|
||||
fprintf(stderr, "Can't parse %s as index\n", name + off);
|
||||
return -EINVAL;
|
||||
}
|
||||
append_preset_atom(preset, var, true);
|
||||
off += n;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1661,7 +1697,7 @@ static int append_var_preset(struct var_preset **presets, int *cnt, const char *
|
|||
void *tmp;
|
||||
struct var_preset *cur;
|
||||
char var[256], val[256];
|
||||
int n, err;
|
||||
int n, err, i;
|
||||
|
||||
tmp = realloc(*presets, (*cnt + 1) * sizeof(**presets));
|
||||
if (!tmp)
|
||||
|
|
@ -1671,10 +1707,16 @@ static int append_var_preset(struct var_preset **presets, int *cnt, const char *
|
|||
memset(cur, 0, sizeof(*cur));
|
||||
(*cnt)++;
|
||||
|
||||
if (sscanf(expr, "%s = %s %n", var, val, &n) != 2 || n != strlen(expr)) {
|
||||
if (sscanf(expr, " %[][a-zA-Z0-9_. ] = %s %n", var, val, &n) != 2 || n != strlen(expr)) {
|
||||
fprintf(stderr, "Failed to parse expression '%s'\n", expr);
|
||||
return -EINVAL;
|
||||
}
|
||||
/* Remove trailing spaces from var, as scanf may add those */
|
||||
for (i = strlen(var) - 1; i > 0; --i) {
|
||||
if (!isspace(var[i]))
|
||||
break;
|
||||
var[i] = '\0';
|
||||
}
|
||||
|
||||
err = parse_rvalue(val, &cur->value);
|
||||
if (err)
|
||||
|
|
@ -1764,22 +1806,96 @@ static bool is_preset_supported(const struct btf_type *t)
|
|||
return btf_is_int(t) || btf_is_enum(t) || btf_is_enum64(t);
|
||||
}
|
||||
|
||||
const int btf_find_member(const struct btf *btf,
|
||||
const struct btf_type *parent_type,
|
||||
__u32 parent_offset,
|
||||
const char *member_name,
|
||||
int *member_tid,
|
||||
__u32 *member_offset)
|
||||
static int find_enum_value(const struct btf *btf, const char *name, long long *value)
|
||||
{
|
||||
const struct btf_type *t;
|
||||
int cnt, i;
|
||||
long long lvalue;
|
||||
|
||||
cnt = btf__type_cnt(btf);
|
||||
for (i = 1; i != cnt; ++i) {
|
||||
t = btf__type_by_id(btf, i);
|
||||
|
||||
if (!btf_is_any_enum(t))
|
||||
continue;
|
||||
|
||||
if (enum_value_from_name(btf, t, name, &lvalue) == 0) {
|
||||
*value = lvalue;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return -ESRCH;
|
||||
}
|
||||
|
||||
static int resolve_rvalue(struct btf *btf, const struct rvalue *rvalue, long long *result)
|
||||
{
|
||||
int err = 0;
|
||||
|
||||
switch (rvalue->type) {
|
||||
case INTEGRAL:
|
||||
*result = rvalue->ivalue;
|
||||
return 0;
|
||||
case ENUMERATOR:
|
||||
err = find_enum_value(btf, rvalue->svalue, result);
|
||||
if (err) {
|
||||
fprintf(stderr, "Can't resolve enum value %s\n", rvalue->svalue);
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
default:
|
||||
fprintf(stderr, "Unknown rvalue type\n");
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int adjust_var_secinfo_array(struct btf *btf, int tid, struct field_access *atom,
|
||||
const char *array_name, struct btf_var_secinfo *sinfo)
|
||||
{
|
||||
const struct btf_type *t;
|
||||
struct btf_array *barr;
|
||||
long long idx;
|
||||
int err;
|
||||
|
||||
tid = btf__resolve_type(btf, tid);
|
||||
t = btf__type_by_id(btf, tid);
|
||||
if (!btf_is_array(t)) {
|
||||
fprintf(stderr, "Array index is not expected for %s\n",
|
||||
array_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
barr = btf_array(t);
|
||||
err = resolve_rvalue(btf, &atom->index, &idx);
|
||||
if (err)
|
||||
return err;
|
||||
if (idx < 0 || idx >= barr->nelems) {
|
||||
fprintf(stderr, "Array index %lld is out of bounds [0, %u]: %s\n",
|
||||
idx, barr->nelems, array_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
sinfo->size = btf__resolve_size(btf, barr->type);
|
||||
sinfo->offset += sinfo->size * idx;
|
||||
sinfo->type = btf__resolve_type(btf, barr->type);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int adjust_var_secinfo_member(const struct btf *btf,
|
||||
const struct btf_type *parent_type,
|
||||
__u32 parent_offset,
|
||||
const char *member_name,
|
||||
struct btf_var_secinfo *sinfo)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!btf_is_composite(parent_type))
|
||||
if (!btf_is_composite(parent_type)) {
|
||||
fprintf(stderr, "Can't resolve field %s for non-composite type\n", member_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
for (i = 0; i < btf_vlen(parent_type); ++i) {
|
||||
const struct btf_member *member;
|
||||
const struct btf_type *member_type;
|
||||
int tid;
|
||||
int tid, off;
|
||||
|
||||
member = btf_members(parent_type) + i;
|
||||
tid = btf__resolve_type(btf, member->type);
|
||||
|
|
@ -1787,6 +1903,7 @@ const int btf_find_member(const struct btf *btf,
|
|||
return -EINVAL;
|
||||
|
||||
member_type = btf__type_by_id(btf, tid);
|
||||
off = parent_offset + member->offset;
|
||||
if (member->name_off) {
|
||||
const char *name = btf__name_by_offset(btf, member->name_off);
|
||||
|
||||
|
|
@ -1796,15 +1913,16 @@ const int btf_find_member(const struct btf *btf,
|
|||
name);
|
||||
return -EINVAL;
|
||||
}
|
||||
*member_offset = parent_offset + member->offset;
|
||||
*member_tid = tid;
|
||||
sinfo->offset += off / 8;
|
||||
sinfo->type = tid;
|
||||
sinfo->size = member_type->size;
|
||||
return 0;
|
||||
}
|
||||
} else if (btf_is_composite(member_type)) {
|
||||
int err;
|
||||
|
||||
err = btf_find_member(btf, member_type, parent_offset + member->offset,
|
||||
member_name, member_tid, member_offset);
|
||||
err = adjust_var_secinfo_member(btf, member_type, off,
|
||||
member_name, sinfo);
|
||||
if (!err)
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1816,26 +1934,39 @@ const int btf_find_member(const struct btf *btf,
|
|||
static int adjust_var_secinfo(struct btf *btf, const struct btf_type *t,
|
||||
struct btf_var_secinfo *sinfo, struct var_preset *preset)
|
||||
{
|
||||
const struct btf_type *base_type, *member_type;
|
||||
int err, member_tid, i;
|
||||
__u32 member_offset = 0;
|
||||
const struct btf_type *base_type;
|
||||
const char *prev_name;
|
||||
int err, i;
|
||||
int tid;
|
||||
|
||||
base_type = btf__type_by_id(btf, btf__resolve_type(btf, t->type));
|
||||
assert(preset->atom_count > 0);
|
||||
assert(preset->atoms[0].type == FIELD_NAME);
|
||||
|
||||
tid = btf__resolve_type(btf, t->type);
|
||||
base_type = btf__type_by_id(btf, tid);
|
||||
prev_name = preset->atoms[0].name;
|
||||
|
||||
for (i = 1; i < preset->atom_count; ++i) {
|
||||
err = btf_find_member(btf, base_type, 0, preset->atoms[i].name,
|
||||
&member_tid, &member_offset);
|
||||
if (err) {
|
||||
fprintf(stderr, "Could not find member %s for variable %s\n",
|
||||
preset->atoms[i].name, preset->atoms[i - 1].name);
|
||||
return err;
|
||||
struct field_access *atom = preset->atoms + i;
|
||||
|
||||
switch (atom->type) {
|
||||
case ARRAY_INDEX:
|
||||
err = adjust_var_secinfo_array(btf, tid, atom, prev_name, sinfo);
|
||||
break;
|
||||
case FIELD_NAME:
|
||||
err = adjust_var_secinfo_member(btf, base_type, 0, atom->name, sinfo);
|
||||
prev_name = atom->name;
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "Unknown field_access type\n");
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
member_type = btf__type_by_id(btf, member_tid);
|
||||
sinfo->offset += member_offset / 8;
|
||||
sinfo->size = member_type->size;
|
||||
sinfo->type = member_tid;
|
||||
base_type = member_type;
|
||||
if (err)
|
||||
return err;
|
||||
base_type = btf__type_by_id(btf, sinfo->type);
|
||||
tid = sinfo->type;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1854,8 +1985,8 @@ static int set_global_var(struct bpf_object *obj, struct btf *btf,
|
|||
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));
|
||||
fprintf(stderr, "Can't set %s. Only ints and enums are supported\n",
|
||||
preset->full_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -1972,6 +2103,7 @@ static int set_global_vars(struct bpf_object *obj, struct var_preset *presets, i
|
|||
if (!presets[i].applied) {
|
||||
fprintf(stderr, "Global variable preset %s has not been applied\n",
|
||||
presets[i].full_name);
|
||||
err = -EINVAL;
|
||||
}
|
||||
presets[i].applied = false;
|
||||
}
|
||||
|
|
@ -3165,11 +3297,18 @@ int main(int argc, char **argv)
|
|||
free(env.deny_filters);
|
||||
for (i = 0; i < env.npresets; ++i) {
|
||||
free(env.presets[i].full_name);
|
||||
for (j = 0; j < env.presets[i].atom_count; ++j)
|
||||
free(env.presets[i].atoms[j].name);
|
||||
for (j = 0; j < env.presets[i].atom_count; ++j) {
|
||||
switch (env.presets[i].atoms[j].type) {
|
||||
case FIELD_NAME:
|
||||
free(env.presets[i].atoms[j].name);
|
||||
break;
|
||||
case ARRAY_INDEX:
|
||||
if (env.presets[i].atoms[j].index.type == ENUMERATOR)
|
||||
free(env.presets[i].atoms[j].index.svalue);
|
||||
break;
|
||||
}
|
||||
}
|
||||
free(env.presets[i].atoms);
|
||||
if (env.presets[i].value.type == ENUMERATOR)
|
||||
free(env.presets[i].value.svalue);
|
||||
}
|
||||
free(env.presets);
|
||||
return -err;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user