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 "struct1[2].struct2[1].u.var_u8[2] = 3" -G "arr[3] = 9"
```
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 <[email protected]>

Author: mykyta5

tools/testing/selftests/bpf/prog_tests/test_veristat.c

@@ -60,12 +60,13 @@ static void test_set_global_vars_succeeds(void)
 	    " -G \"var_s8 = -128\" "\
 	    " -G \"var_u8 = 255\" "\
 	    " -G \"var_ea = EA2\" "\
-	    " -G \"var_eb = EB2\" "\
-	    " -G \"var_ec = EC2\" "\
+	    " -G \"var_eb  =  EB2\" "\
+	    " -G \"var_ec=EC2\" "\
 	    " -G \"var_b = 1\" "\
-	    " -G \"struct1.struct2.u.var_u8 = 170\" "\
+	    " -G \"struct1[2].struct2[1].u.var_u8[2]=170\" "\
 	    " -G \"union1.struct3.var_u8_l = 0xaa\" "\
 	    " -G \"union1.struct3.var_u8_h = 0xaa\" "\
+	    " -G \"arr[2] = 0xaa\" "	\
 	    "-vl2 > %s", fix->veristat, fix->tmpfile);
 
 	read(fix->fd, fix->output, fix->sz);
@@ -81,7 +82,7 @@ static void test_set_global_vars_succeeds(void)
 	__CHECK_STR("_w=12 ", "var_eb = EB2");
 	__CHECK_STR("_w=13 ", "var_ec = EC2");
 	__CHECK_STR("_w=1 ", "var_b = 1");
-	__CHECK_STR("_w=170 ", "struct1.struct2.u.var_u8 = 170");
+	__CHECK_STR("_w=170 ", "struct1.struct2[1].u.var_u8[2] = 170");
 	__CHECK_STR("_w=0xaaaa ", "union1.var_u16 = 0xaaaa");
 
 out:

tools/testing/selftests/bpf/progs/set_global_vars.c

@@ -23,6 +23,7 @@ const volatile enum Enum var_ea = EA1;
 const volatile enum Enumu64 var_eb = EB1;
 const volatile enum Enums64 var_ec = EC1;
 const volatile bool var_b = false;
+const volatile __s32 arr[5];
 
 struct Struct {
 	int:16;
@@ -35,16 +36,16 @@ struct Struct {
 		volatile struct {
 			const int:1;
 			union {
-				const volatile __u8 var_u8;
+				const volatile __u8 var_u8[3];
 				const volatile __s16 filler3;
 				const int:1;
 			} u;
 		};
-	} struct2;
+	} struct2[2];
 };
 
 const volatile __u32 stru = 0; /* same prefix as below */
-const volatile struct Struct struct1 = {.struct2 = {.u = {.var_u8 = 1}}};
+const volatile struct Struct struct1[3] = {{.struct2 = {{}, {.u = {.var_u8 = {1}}}}}};
 
 union Union {
 	__u16 var_u16;
@@ -62,8 +63,6 @@ union Union {
 
 const volatile union Union union1 = {.var_u16 = -1};
 
-char arr[4] = {0};
-
 SEC("socket")
 int test_set_globals(void *ctx)
 {
@@ -81,8 +80,9 @@ int test_set_globals(void *ctx)
 	a = var_eb;
 	a = var_ec;
 	a = var_b;
-	a = struct1.struct2.u.var_u8;
+	a = struct1[2].struct2[1].u.var_u8[2];
 	a = union1.var_u16;
+	a = arr[3];
 
 	return a;
 }

tools/testing/selftests/bpf/veristat.c

@@ -1379,7 +1379,7 @@ 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;
 	}
@@ -1486,14 +1486,47 @@ 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 adjust_array_secinfo(const struct btf *btf, const struct btf_type *t,
+				struct btf_var_secinfo *sinfo, const char *var)
+{
+	struct btf_array *barr;
+	const struct btf_type *type;
+	char arr[64], idx[64];
+	int i = 0, tid;
+
+	if (!btf_is_array(t))
+		return 0;
+
+	barr = btf_array(t);
+	tid = btf__resolve_type(btf, barr->type);
+	type = btf__type_by_id(btf, tid);
+
+	/* var may contain chained expression e.g.: foo[1].bar */
+	if (sscanf(var, "%[a-zA-Z0-9_][%[a-zA-Z0-9]]", arr, idx) != 2) {
+		fprintf(stderr, "Could not parse array expression %s\n", var);
+		return -EINVAL;
+	}
+	errno = 0;
+	i = strtol(idx, NULL, 0);
+	if (errno || i < 0 || i >= barr->nelems) {
+		fprintf(stderr, "Preset index %s is invalid or out of bounds [0, %d]\n",
+			idx, barr->nelems);
+		return -EINVAL;
+	}
+	sinfo->size = type->size;
+	sinfo->type = tid;
+	sinfo->offset += i * type->size;
+	return 0;
+}
+
 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)
 {
-	int i;
+	int i, err;
 
 	if (!btf_is_composite(parent_type))
 		return -EINVAL;
@@ -1511,15 +1544,29 @@ const int btf_find_member(const struct btf *btf,
 		member_type = btf__type_by_id(btf, tid);
 		if (member->name_off) {
 			const char *name = btf__name_by_offset(btf, member->name_off);
+			int name_len = strlen(name);
 
-			if (strcmp(member_name, name) == 0) {
+			if (strcmp(member_name, name) == 0 ||
+			    (btf_is_array(member_type) &&
+			     strncmp(name, member_name, name_len) == 0 &&
+			     member_name[name_len] == '[')) {
 				if (btf_member_bitfield_size(parent_type, i) != 0) {
 					fprintf(stderr, "Bitfield presets are not supported %s\n",
 						name);
 					return -EINVAL;
 				}
 				*member_offset = parent_offset + member->offset;
 				*member_tid = tid;
+				if (btf_is_array(member_type)) {
+					struct btf_var_secinfo sinfo = {.offset = 0};
+
+					err = adjust_array_secinfo(btf, member_type,
+								   &sinfo, member_name);
+					if (err)
+						return err;
+					*member_tid = sinfo.type;
+					*member_offset += sinfo.offset * 8;
+				}
 				return 0;
 			}
 		} else if (btf_is_composite(member_type)) {
@@ -1548,6 +1595,13 @@ static int adjust_var_secinfo(struct btf *btf, const struct btf_type *t,
 	snprintf(expr, sizeof(expr), "%s", var);
 	strtok_r(expr, ".", &saveptr);
 
+	if (btf_is_array(base_type)) {
+		err = adjust_array_secinfo(btf, base_type, sinfo, var);
+		if (err)
+			return err;
+		base_type = btf__type_by_id(btf, sinfo->type);
+	}
+
 	while ((name = strtok_r(NULL, ".", &saveptr))) {
 		err = btf_find_member(btf, base_type, 0, name, &member_tid, &member_offset);
 		if (err) {
@@ -1673,7 +1727,8 @@ static int set_global_vars(struct bpf_object *obj, struct var_preset *presets, i
 
 				if (strncmp(var_name, presets[k].name, var_len) != 0 ||
 				    (presets[k].name[var_len] != '\0' &&
-				     presets[k].name[var_len] != '.'))
+				     presets[k].name[var_len] != '.' &&
+				     presets[k].name[var_len] != '['))
 					continue;
 
 				if (presets[k].applied) {