[PATCH 2/4] selftests/resctrl: Add MBA schemata write/read-back selftest

[Richard Cheng <icheng@nvidia.com>]

Implement MBA schemata rw test, in a temporary control group,
write a few legal percentages to each MB domain, read each
back through the schemata then restore the maximum and remove the group.
Domain ids are taken from the schemata.

Add a resctrl_write_schemata() helper for the raw write.

Signed-off-by: Richard Cheng <icheng@nvidia.com>
---
 .../selftests/resctrl/mba_schemata_test.c     | 115 ++++++++++++++++++
 tools/testing/selftests/resctrl/resctrl.h     |   2 +
 .../testing/selftests/resctrl/resctrl_tests.c |   1 +
 tools/testing/selftests/resctrl/resctrlfs.c   |  36 ++++++
 4 files changed, 154 insertions(+)

diff --git a/tools/testing/selftests/resctrl/mba_schemata_test.c b/tools/testing/selftests/resctrl/mba_schemata_test.c
index b92011e42726..ff101b814982 100644
--- a/tools/testing/selftests/resctrl/mba_schemata_test.c
+++ b/tools/testing/selftests/resctrl/mba_schemata_test.c
@@ -150,3 +150,118 @@ struct resctrl_test mba_schemata_info_test = {
 	.feature_check = mba_schemata_feature_check,
 	.run_test = mba_schemata_info_run_test,
 };
+
+/* Read back the percentage for one MB domain from a group's schemata. */
+static int mb_read_domain(const char *ctrlgrp, const char *resource, int dom,
+			  unsigned int *out)
+{
+	unsigned int pct[MB_MAX_DOMAINS];
+	int ids[MB_MAX_DOMAINS], n, i;
+	char vals[MB_SCHEMATA_LEN];
+
+	if (resctrl_get_schemata(ctrlgrp, resource, vals, sizeof(vals)))
+		return -1;
+	n = parse_mb_schemata(vals, ids, pct, MB_MAX_DOMAINS);
+	for (i = 0; i < n; i++) {
+		if (ids[i] == dom) {
+			*out = pct[i];
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+/*
+ * writing a legal percentage to a domain takes effect
+ * and reads back, and restoring the maximum works.
+ * Domain ids come from the schemata directly.
+ */
+static int mba_schemata_rw_run_test(const struct resctrl_test *test,
+				    const struct user_params *uparams)
+{
+	static const unsigned int cand[] = { 10, 50, 90 };
+	unsigned int gran, pct[MB_MAX_DOMAINS], receive = 0;
+	int ids[MB_MAX_DOMAINS], n, i, j, ret, fail = 0;
+	char vals[MB_SCHEMATA_LEN], grp_path[256], line[64];
+	const char *grp = "mba_schemata_rw";
+
+	if (resource_info_unsigned_get(test->resource, "bandwidth_gran", &gran))
+		return 1;
+
+	/* Enumerate the real MB domain ids from the default schemata. */
+	ret = resctrl_get_schemata("", test->resource, vals, sizeof(vals));
+	if (ret) {
+		ksft_print_msg("Fail: could not read %s schemata line (ret=%d)\n",
+			       test->resource, ret);
+		return 1;
+	}
+	n = parse_mb_schemata(vals, ids, pct, MB_MAX_DOMAINS);
+	if (n < 1) {
+		ksft_print_msg("Fail: could not parse %s schemata \"%s\"\n",
+			       test->resource, vals);
+		return 1;
+	}
+
+	snprintf(grp_path, sizeof(grp_path), "%s/%s", RESCTRL_PATH, grp);
+	if (mkdir(grp_path, 0755) && errno != EEXIST) {
+		ksft_print_msg("Fail: mkdir %s: %m\n", grp_path);
+		return 1;
+	}
+
+	for (i = 0; i < n; i++) {
+		for (j = 0; j < (int)ARRAY_SIZE(cand); j++) {
+			snprintf(line, sizeof(line), "%s:%d=%u",
+				 test->resource, ids[i], cand[j]);
+			ret = resctrl_write_schemata(grp, line);
+			if (ret) {
+				ksft_print_msg("Fail: write \"%s\" (ret=%d)\n", line, ret);
+				fail = 1;
+				continue;
+			}
+			if (mb_read_domain(grp, test->resource, ids[i], &receive)) {
+				ksft_print_msg("Fail: read back %s domain %d\n",
+					       test->resource, ids[i]);
+				fail = 1;
+				continue;
+			}
+			if (abs((int)receive - (int)cand[j]) > (int)gran) {
+				ksft_print_msg("Fail: %s domain %d: %u%% -> %u%% (gran %u)\n",
+					       test->resource, ids[i], cand[j], receive, gran);
+				fail = 1;
+			} else {
+				ksft_print_msg("Pass: %s domain %d %u%% -> read %u%%\n",
+					       test->resource, ids[i], cand[j], receive);
+			}
+		}
+
+		/* Restore the maximum and confirm. */
+		snprintf(line, sizeof(line), "%s:%d=%u",
+			 test->resource, ids[i], MB_PERCENT_MAX);
+		ret = resctrl_write_schemata(grp, line);
+		if (ret) {
+			ksft_print_msg("Fail: restore write \"%s\" (ret=%d)\n", line, ret);
+			fail = 1;
+		} else if (mb_read_domain(grp, test->resource, ids[i], &receive) ||
+			   receive != MB_PERCENT_MAX) {
+			ksft_print_msg("Fail: %s domain %d not restored to %u%% (received %u)\n",
+				       test->resource, ids[i], MB_PERCENT_MAX, receive);
+			fail = 1;
+		} else {
+			ksft_print_msg("Pass: %s domain %d restored to %u%%\n",
+				       test->resource, ids[i], MB_PERCENT_MAX);
+		}
+	}
+
+	rmdir(grp_path);
+
+	return fail;
+}
+
+struct resctrl_test mba_schemata_rw_test = {
+	.name = "MBA_SCHEMATA_RW",
+	.group = "MBA_SCHEMATA",
+	.resource = "MB",
+	.feature_check = mba_schemata_feature_check,
+	.run_test = mba_schemata_rw_run_test,
+};
diff --git a/tools/testing/selftests/resctrl/resctrl.h b/tools/testing/selftests/resctrl/resctrl.h
index a6ad25a08ae5..75d1ad5c6968 100644
--- a/tools/testing/selftests/resctrl/resctrl.h
+++ b/tools/testing/selftests/resctrl/resctrl.h
@@ -203,6 +203,7 @@ int get_cache_size(int cpu_no, const char *cache_type, unsigned long *cache_size
 int resource_info_unsigned_get(const char *resource, const char *filename, unsigned int *val);
 int resource_info_str_get(const char *resource, const char *filename, char *val, size_t len);
 int resctrl_get_schemata(const char *ctrlgrp, const char *resource, char *buf, size_t len);
+int resctrl_write_schemata(const char *ctrlgrp, const char *line);
 void ctrlc_handler(int signum, siginfo_t *info, void *ptr);
 int signal_handler_register(const struct resctrl_test *test);
 void signal_handler_unregister(void);
@@ -249,5 +250,6 @@ extern struct resctrl_test l3_cat_test;
 extern struct resctrl_test l3_noncont_cat_test;
 extern struct resctrl_test l2_noncont_cat_test;
 extern struct resctrl_test mba_schemata_info_test;
+extern struct resctrl_test mba_schemata_rw_test;
 
 #endif /* RESCTRL_H */
diff --git a/tools/testing/selftests/resctrl/resctrl_tests.c b/tools/testing/selftests/resctrl/resctrl_tests.c
index 5d45ac95d988..9b3ac0437bf9 100644
--- a/tools/testing/selftests/resctrl/resctrl_tests.c
+++ b/tools/testing/selftests/resctrl/resctrl_tests.c
@@ -22,6 +22,7 @@ static struct resctrl_test *resctrl_tests[] = {
 	&l3_noncont_cat_test,
 	&l2_noncont_cat_test,
 	&mba_schemata_info_test,
+	&mba_schemata_rw_test,
 };
 
 static unsigned int detect_vendor(void)
diff --git a/tools/testing/selftests/resctrl/resctrlfs.c b/tools/testing/selftests/resctrl/resctrlfs.c
index 8b428a22496d..1196418461b5 100644
--- a/tools/testing/selftests/resctrl/resctrlfs.c
+++ b/tools/testing/selftests/resctrl/resctrlfs.c
@@ -521,6 +521,42 @@ int resctrl_get_schemata(const char *ctrlgrp, const char *resource,
 	return ret;
 }
 
+/*
+ * resctrl_write_schemata - Write a raw schemata line to a group's schemata file
+ * @ctrlgrp:	Control group name, or "" / NULL for the default group
+ * @line:	Full schemata line without newline, e.g. "MB:0=50"
+ *
+ * Unlike write_schemata(), the caller supplies the exact
+ * "<resource>:<domain>=<value>", so this works where the domain id is not the
+ * CPU's L3 cache id (e.g. ARM MPAM, whose MB domains are NUMA proximity ids).
+ *
+ * Return: 0 on success, or -errno on failure (e.g. -EINVAL for a value the
+ * kernel rejects).
+ */
+int resctrl_write_schemata(const char *ctrlgrp, const char *line)
+{
+	char path[1024], buf[1024];
+	int fd, len, ret = 0;
+
+	if (ctrlgrp && *ctrlgrp)
+		snprintf(path, sizeof(path), "%s/%s/schemata", RESCTRL_PATH, ctrlgrp);
+	else
+		snprintf(path, sizeof(path), "%s/schemata", RESCTRL_PATH);
+
+	len = snprintf(buf, sizeof(buf), "%s\n", line);
+	if (len < 0 || (size_t)len >= sizeof(buf))
+		return -EOVERFLOW;
+
+	fd = open(path, O_WRONLY);
+	if (fd < 0)
+		return -errno;
+	if (write(fd, buf, len) < 0)
+		ret = -errno;
+	close(fd);
+
+	return ret;
+}
+
 /*
  * create_bit_mask- Create bit mask from start, len pair
  * @start:	LSB of the mask
-- 
2.43.0