Skip to contentSkip to conversation

selftests/bpf: implement setting global variables in veristat

PATCH Superseded Mykyta Yatsenko 3 participants 5 messages Feb 21, 2025 – Feb 25, 2025

Subsystems (3)

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v4 cover selftests/bpf: implement setting global variables in veristat

From: Mykyta Yatsenko <[email protected]>

To better verify some complex BPF programs by veristat, it would be useful to preset global variables. This patch set implements this functionality and introduces tests for veristat.

v3->v4:
* Fixing bug in set_global_var introduced by refactoring in previous patch set.
* Addressed nits from Eduard

v2->v3:
* Reworked parsing of the presets, using sscanf to split into variable and value, but
still use strtoll/strtoull to support range checks when parsing integers
* Fix test failures for no_alu32 & cpuv4 by checking if veristat binary is in parent folder
* Introduce __CHECK_STR macro for simplifying checks in test
* Modify tests into sub-tests

Mykyta Yatsenko (2):
selftests/bpf: implement setting global variables in veristat selftests/bpf: introduce veristat test

 tools/testing/selftests/bpf/Makefile          |   1 +
 .../selftests/bpf/prog_tests/test_veristat.c  | 139 +++++++++
 .../selftests/bpf/progs/set_global_vars.c     |  47 +++
 tools/testing/selftests/bpf/test_progs.h      |   8 +
 tools/testing/selftests/bpf/veristat.c        | 290 +++++++++++++++++-
 5 files changed, 484 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/test_veristat.c
 create mode 100644 tools/testing/selftests/bpf/progs/set_global_vars.c
Signature · 1 line
2.48.1
#1 lore raw

PATCH v4 1/2 selftests/bpf: implement setting global variables in veristat

From: Mykyta Yatsenko <[email protected]>

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"
```
---
 tools/testing/selftests/bpf/veristat.c | 290 ++++++++++++++++++++++++-
 1 file changed, 289 insertions(+), 1 deletion(-)
tools/testing/selftests/bpf/veristat.c +289 -1
index 06af5029885b..1e1bc0dfa50a 100644
@@ -154,6 +154,16 @@ struct filter {
 	bool abs;
 };
 
+struct var_preset {
+	char *name;
+	enum { INTEGRAL, NAME } type;
+	union {
+		long long ivalue;
+		char *svalue;
+	};
+	bool applied;
+};
+
 static struct env {
 	char **filenames;
 	int filename_cnt;
@@ -195,6 +205,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 +258,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', "GLOBALS", 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)
 {
@@ -363,6 +378,19 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state)
 			return -ENOMEM;
 		env.filename_cnt++;
 		break;
+	case 'G': {
+		if (arg[0] == '@') {
+			if (append_var_preset_file(arg + 1)) {
+				fprintf(stderr, "Could not parse global variables preset: %s\n",
+					arg);
+				argp_usage(state);
+			}
+		} else if (append_var_preset(&env.presets, &env.npresets, arg)) {
+			fprintf(stderr, "Could not parse global variables preset: %s\n", arg);
+			argp_usage(state);
+		}
+		break;
+	}
 	default:
 		return ARGP_ERR_UNKNOWN;
 	}
@@ -632,7 +660,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 +1320,249 @@ 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];
+
+	tmp = realloc(*presets, (*cnt + 1) * sizeof(**presets));
+	if (!tmp)
+		return -ENOMEM;
+	*presets = tmp;
+	cur = &(*presets)[*cnt];
+	cur->applied = false;
+
+	if (sscanf(expr, "%s = %s\n", var, val) != 2) {
+		fprintf(stderr, "Could not parse expression %s\n", expr);
+		return -EINVAL;
+	}
+
+	if (isalpha(*val)) {
+		cur->svalue = strdup(val);
+		cur->type = NAME;
+	} else if (*val == '-' || isdigit(*val)) {
+		long long value;
+
+		errno = 0;
+		value = strtoll(val, NULL, 0);
+		if (errno == ERANGE) {
+			errno = 0;
+			value = strtoull(val, NULL, 0);
+		}
+		cur->ivalue = value;
+		cur->type = INTEGRAL;
+		if (errno) {
+			fprintf(stderr, "Could not parse integer value %s\n", val);
+			return -EINVAL;
+		}
+	} else {
+		fprintf(stderr, "Could not parse value %s\n", val);
+		return -EINVAL;
+	}
+	cur->name = strdup(var);
+	(*cnt)++;
+	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, "Could not resolve type %d\n", t->type);
+		return -EINVAL;
+	}
+	if (!is_preset_supported(base_type)) {
+		fprintf(stderr, "Setting global variable for btf kind %d is not supported\n",
+			btf_kind(base_type));
+		return -EINVAL;
+	}
+
+	if (preset->type == NAME && btf_is_any_enum(base_type)) {
+		if (enum_value_from_name(btf, base_type, preset->svalue, &value) != 0) {
+			fprintf(stderr, "Could not find integer value for enum element %s\n",
+				preset->svalue);
+			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 = (void *)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 if (__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 +1612,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\n");
+			goto cleanup;
+		}
 		process_prog(filename, obj, prog);
 		goto cleanup;
 	}
@@ -1355,6 +1631,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\n");
+			goto cleanup;
+		}
+
 		lprog = NULL;
 		bpf_object__for_each_program(tprog, tobj) {
 			const char *tprog_name = bpf_program__name(tprog);
@@ -2460,5 +2742,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 == NAME)
+			free(env.presets[i].svalue);
+	}
+	free(env.presets);
 	return -err;
 }
Signature · 1 line
2.48.1
#2 lore raw
Quoted 38 lines · Mykyta Yatsenko

From: Mykyta Yatsenko <[email protected]>

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"
```
Quoted 5 lines
---
 tools/testing/selftests/bpf/veristat.c | 290 ++++++++++++++++++++++++-
 1 file changed, 289 insertions(+), 1 deletion(-)

Just a few minor things below, but overall looks great!

Quoted 31 lines
tools/testing/selftests/bpf/veristat.c +12 -0
index 06af5029885b..1e1bc0dfa50a 100644
@@ -154,6 +154,16 @@ struct filter {
        bool abs;
 };
 
+struct var_preset {
+       char *name;
+       enum { INTEGRAL, NAME } type;
+       union {
+               long long ivalue;
+               char *svalue;
+       };
+       bool applied;
+};
+
 static struct env {
        char **filenames;
        int filename_cnt;
@@ -195,6 +205,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)

tools/testing/selftests/bpf/veristat.c static const struct argp_option opts[] = { · line 261

Quoted 4 lines
tools/testing/selftests/bpf/veristat.c +1 -0
@@ -246,12 +258,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', "GLOBALS", 0, "Set global variables provided in the expression, for example \"var1 = 1\"" },

GLOBAL (singular)

Quoted 3 lines
tools/testing/selftests/bpf/veristat.c +0 -0
        {},
 };
 

[...]

Quoted 9 lines
tools/testing/selftests/bpf/veristat.c +9 -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];
+
+       tmp = realloc(*presets, (*cnt + 1) * sizeof(**presets));
+       if (!tmp)
+               return -ENOMEM;

tools/testing/selftests/bpf/veristat.c static int process_prog(const char *filename, struct bpf_object *obj, struct bpf · line 1341

Quoted 10 lines
tools/testing/selftests/bpf/veristat.c +10 -0
+       *presets = tmp;
+       cur = &(*presets)[*cnt];
+       cur->applied = false;
+
+       if (sscanf(expr, "%s = %s\n", var, val) != 2) {
+               fprintf(stderr, "Could not parse expression %s\n", expr);
+               return -EINVAL;
+       }
+
+       if (isalpha(*val)) {

technically enum could be _WHATEVER, underscore is legal character

tools/testing/selftests/bpf/veristat.c static int process_prog(const char *filename, struct bpf_object *obj, struct bpf · line 1343

Quoted 2 lines
tools/testing/selftests/bpf/veristat.c +2 -0
+               cur->svalue = strdup(val);
+               cur->type = NAME;

total nit, but NAME confused me a bit, as I assumed that the name of the global variable. It's really just for enums, right? So ENUM or ENUMERATOR would make sense and be more precise?

Quoted 1 line

+ } else if (*val == '-' || isdigit(*val)) {

instead of doing this detection based on characters, why not try to parse a number (and I'd use sscanf("%lli") which will handle 1234 and 0x1234 transparently)? And you can use %n to check that all characters were parsed (i.e., you have exact match)

it's probably fine for starters, but it kind of sucks that 0x1234 isn't supported

Quoted 9 lines
tools/testing/selftests/bpf/veristat.c +9 -0
+               long long value;
+
+               errno = 0;
+               value = strtoll(val, NULL, 0);
+               if (errno == ERANGE) {
+                       errno = 0;
+                       value = strtoull(val, NULL, 0);
+               }
+               cur->ivalue = value;

tools/testing/selftests/bpf/veristat.c static int process_prog(const char *filename, struct bpf_object *obj, struct bpf · line 1363

Quoted 10 lines
tools/testing/selftests/bpf/veristat.c +10 -0
+               cur->type = INTEGRAL;
+               if (errno) {
+                       fprintf(stderr, "Could not parse integer value %s\n", val);
+                       return -EINVAL;
+               }
+       } else {
+               fprintf(stderr, "Could not parse value %s\n", val);
+               return -EINVAL;
+       }
+       cur->name = strdup(var);

check for NULL and error out? (no need for logging message, it's rare to get ENOMEM)

pw-bot: cr

Quoted 4 lines
tools/testing/selftests/bpf/veristat.c +4 -0
+       (*cnt)++;
+       return 0;
+}
+

[...]

Quoted 6 lines
tools/testing/selftests/bpf/veristat.c +6 -0
+       /* 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;
+

tools/testing/selftests/bpf/veristat.c static int process_prog(const char *filename, struct bpf_object *obj, struct bpf · line 1484

Quoted 10 lines
tools/testing/selftests/bpf/veristat.c +10 -0
+               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 = (void *)bpf_map__initial_value(map, &size);

it already returns void *, no need to cast

Quoted 1 line

+ if (!ptr || (sinfo->offset + sinfo->size > size))

nit: unnecessary ()

tools/testing/selftests/bpf/veristat.c static int process_prog(const char *filename, struct bpf_object *obj, struct bpf · line 1490

Quoted 5 lines
tools/testing/selftests/bpf/veristat.c +5 -0
+               return -EINVAL;
+
+       if (__BYTE_ORDER == __LITTLE_ENDIAN) {
+               memcpy(ptr + sinfo->offset, &value, sinfo->size);
+       } else if (__BYTE_ORDER == __BIG_ENDIAN) {

either this if condition is superficial, or we'd need to add another else with error. let's just

} else { /* __BYTE_ORDER == __BIG_ENDIAN */
memcpy()
}

?

Quoted 7 lines
tools/testing/selftests/bpf/veristat.c +7 -0
+               __u8 src_offset = sizeof(value) - sinfo->size;
+
+               memcpy(ptr + sinfo->offset, (void *)&value + src_offset, sinfo->size);
+       }
+       return 0;
+}
+

[...]

tools/testing/selftests/bpf/veristat.c static int process_obj(const char *filename) · line 1617

Quoted 10 lines

static int process_obj(const char *filename)

 {
        const char *base_filename = basename(strdupa(filename));
tools/testing/selftests/bpf/veristat.c +3 -0
@@ -1341,6 +1612,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\n");

emit error code to help with debugging in the future? same below

Quoted 5 lines
tools/testing/selftests/bpf/veristat.c +2 -0
+                       goto cleanup;
+               }
                process_prog(filename, obj, prog);
                goto cleanup;
        }

[...]

maintainer
#3 lore raw

On Mon, 2025-02-24 at 16:38 -0800, Andrii Nakryiko wrote:

[...]

Quoted 9 lines
Quoted 1 line

+ } else if (*val == '-' || isdigit(*val)) {

instead of doing this detection based on characters, why not try to parse a number (and I'd use sscanf("%lli") which will handle 1234 and 0x1234 transparently)? And you can use %n to check that all characters were parsed (i.e., you have exact match)

it's probably fine for starters, but it kind of sucks that 0x1234 isn't supported

(Nit: {strtoull,strtoll}(val, NULL, 0) supports decimal and hexadecimal notations).

[...]

#4 lore raw

PATCH v4 2/2 selftests/bpf: introduce veristat test

In reply to Mykyta Yatsenko

From: Mykyta Yatsenko <[email protected]>

Introducing test for veristat, part of test_progs.
Test cases cover functionality of setting global variables in BPF program.

---
 tools/testing/selftests/bpf/Makefile          |   1 +
 .../selftests/bpf/prog_tests/test_veristat.c  | 139 ++++++++++++++++++
 .../selftests/bpf/progs/set_global_vars.c     |  47 ++++++
 tools/testing/selftests/bpf/test_progs.h      |   8 +
 4 files changed, 195 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/test_veristat.c
 create mode 100644 tools/testing/selftests/bpf/progs/set_global_vars.c
tools/testing/selftests/bpf/Makefile +1 -0
index 0d552bfcfe7d..5e9d3c91c6db 100644
@@ -690,6 +690,7 @@ $(OUTPUT)/$(TRUNNER_BINARY): $(TRUNNER_TEST_OBJS)			\
 			     $(TRUNNER_EXTRA_OBJS) $$(BPFOBJ)		\
 			     $(RESOLVE_BTFIDS)				\
 			     $(TRUNNER_BPFTOOL)				\
+			     $(OUTPUT)/veristat				\
 			     | $(TRUNNER_BINARY)-extras
 	$$(call msg,BINARY,,$$@)
 	$(Q)$$(CC) $$(CFLAGS) $$(filter %.a %.o,$$^) $$(LDLIBS) $$(LDFLAGS) -o $$@
tools/testing/selftests/bpf/prog_tests/test_veristat.c new file +139 -0

139 lines not on this page · raw message

tools/testing/selftests/bpf/progs/set_global_vars.c new file +47 -0

47 lines not on this page · raw message

tools/testing/selftests/bpf/test_progs.h +8 -0
index 404d0d4915d5..870694f2a359 100644
@@ -427,6 +427,14 @@ void hexdump(const char *prefix, const void *buf, size_t len);
 			goto goto_label;				\
 	})
 
+#define SYS_FAIL(goto_label, fmt, ...)					\
+	({								\
+		char cmd[1024];						\
+		snprintf(cmd, sizeof(cmd), fmt, ##__VA_ARGS__);		\
+		if (!ASSERT_NEQ(0, system(cmd), cmd))			\
+			goto goto_label;				\
+	})
+
 #define ALL_TO_DEV_NULL " >/dev/null 2>&1"
 
 #define SYS_NOFAIL(fmt, ...)						\
Signature · 1 line
2.48.1