add fs_mark harness

JIRA: CI-307

fs_mark/Makefile

@@ -0,0 +1 @@
+$(eval $(call add_test, fs_mark_clean))

fs_mark/fs_mark.py

@@ -0,0 +1,126 @@
+import trunner
+import time
+import yaml
+import pexpect
+import timing_data as t_data
+import psh.tools.psh as psh
+
+from trunner.ctx import TestContext
+from trunner.dut import Dut
+from trunner.types import TestResult, TestSubResult, Status
+
+
+def harness(dut: Dut, ctx: TestContext, result: TestResult):
+    test_name = None
+    test_status = Status.OK
+    f_use = None
+    count = None
+    size = None
+    files_sec = None
+    app_overhead = None
+    subresult = None
+    got_time = False
+    clean = False
+    logs_path ='~/remote/logs/fs_mark_logs'
+    target = trunner.ctx.target.name
+
+    NAME = r"(.+?)/bin/(?P<name>fs_mark.+?)\r+\n"
+    MSG_LINE = r"(?P<line>(\s+\d+[\d\.]*){23})\r+\n"
+    #MSG_LINE = r"(?P<line>(((\s+)(\d+(\.\d+)?)){23}))\r+\n"
+   # r"(\s+)(?P<line>([\d\.]+\s*){23})\r+\n"
+    FINAL = r"(?P<final>Insufficient free space.+?)\r+\n"
+    END = r"(?P<end>Average Files/sec:.+?)\r+\n"
+
+    start_time = None
+    end_time = None
+    loop_time = 600
+
+    while True:
+        if start_time and end_time:
+            loop_time = 3 * (end_time - start_time)
+            start_time = None
+            end_time = None
+
+        try:
+            idx = dut.expect([
+                NAME,
+                MSG_LINE,
+                FINAL,
+                END
+            ], timeout=loop_time)
+            parsed = dut.match.groupdict()
+
+        except pexpect.TIMEOUT:
+            test_status = Status.FAIL
+            subresult = TestSubResult(name=str(test_name), msg="Timeout, probably filesystem hang-up", status=Status.FAIL)
+            result.add_subresult_obj(subresult)
+            break
+
+        if idx == 0:
+            test_name = parsed["name"]
+            if '-k' in test_name or '-L' in test_name or '-F' in test_name:
+                clean = True
+            start_time = time.time()
+        elif idx == 1:
+            got_time = True
+            splited_line = parsed["line"].split()
+            f_use = splited_line[0]
+            count = splited_line[1]
+            size = splited_line[2]
+            files_sec = splited_line[3]
+            app_overhead = splited_line[4]
+
+            dict = {}
+            dict['creatMin'] = splited_line[5]
+            dict['creatAvg'] = splited_line[6]
+            dict['creatMax'] = splited_line[7]
+            dict['writeMin'] = splited_line[8]
+            dict['writeAvg'] = splited_line[9]
+            dict['writeMax'] = splited_line[10]
+            dict['closeMin'] = splited_line[17]
+            dict['closeAvg'] = splited_line[18]
+            dict['closeMax'] = splited_line[19]
+
+            try:
+                with open(logs_path, 'a') as file:
+                    yaml.dump(dict, file)
+            except FileNotFoundError:
+                print(f'Logs filepath: {logs_path} does not exist')
+
+            subresult = TestSubResult(name=str(test_name), status=Status.OK)
+
+            for name, value in dict.items():
+                if not t_data.timing_dict[(target, name)][0] <= int(value) <= t_data.timing_dict[(target, name)][1]:
+                    test_status = Status.FAIL
+                    subresult.status = Status.FAIL
+                    subresult.msg += "\n\t" + name + " exec time - " + value + \
+                                     " out of range [" + str(t_data.timing_dict[(target, name)][0]) + \
+                                     " - " + str(t_data.timing_dict[(target, name)][1]) + "]"
+
+            if subresult.status == Status.FAIL:
+                subresult.msg += "\n\n\tF_Use%: " + str(f_use)
+                subresult.msg += "\n\tCount: " + str(count)
+                subresult.msg += "\n\tSize: " + str(size)
+                subresult.msg += "\n\tFiles/sec: " + str(files_sec)
+                subresult.msg += "\n\tApp overhead: " + str(app_overhead) + "\n\t"
+
+            if subresult.status == Status.FAIL:
+                result.add_subresult_obj(subresult)
+                subresult = None
+                break
+
+        elif idx == 2 or idx == 3:
+            end_time = time.time()
+            if got_time is False:
+                subresult = TestSubResult(name=str(test_name), status=Status.FAIL)
+                subresult.msg += "\n\tGot no timings"
+
+            result.add_subresult_obj(subresult)
+            subresult = None
+
+            if clean is True:
+                psh._send(dut, '/bin/fs_mark_clean /tmp/2')
+
+            break
+
+    return TestResult(status=test_status)

fs_mark/fs_mark_clean.c

@@ -0,0 +1,84 @@
+/*
+ * Phoenix-RTOS
+ *
+ * Cleanup after fs_mark (usage with keeping files).
+ *
+ * Copyright 2023 Phoenix Systems
+ * Author: Adam Debek
+ *
+ * This file is part of Phoenix-RTOS.
+ *
+ * %LICENSE%
+ */
+
+#include <stdint.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <string.h>
+#include <limits.h>
+
+int remove_dir_recursive(const char *dirPath)
+{
+	DIR *dir = opendir(dirPath);
+	struct dirent *entry;
+	char filename[PATH_MAX];
+	int (*remove_func)(const char *);
+
+	if (dir) {
+		if (chdir(dirPath) < 0) {
+			printf("chdir failed, path: %s\n", dirPath);
+			exit(1);
+		}
+
+		while ((entry = readdir(dir))) {
+			if (!strcmp(".", entry->d_name) || !strcmp("..", entry->d_name)) {
+				continue;
+			}
+			sprintf(filename, "%s/%s", dirPath, entry->d_name);
+			remove_func = entry->d_type == dtDir ? remove_dir_recursive : remove;
+			if (remove_func(filename)) {
+				closedir(dir);
+				return -1;
+			}
+			if (chdir(dirPath) < 0) {
+				printf("chdir failed, path: %s\n", dirPath);
+				exit(1);
+			}
+		}
+
+		if (closedir(dir)) {
+			return -1;
+		}
+	}
+	return rmdir(dirPath);
+}
+
+int main(int argc, char **argv)
+{
+	int i;
+	DIR *dir;
+
+	if (argc < 2) {
+		fprintf(stderr, "Usage: %s [dir1] ... [dirN]\n", argv[0]);
+		return 1;
+	}
+
+	for (i = 1; i < argc; i++) {
+		if ((dir = opendir(argv[i])) == NULL) {
+			fprintf(stderr, "Nonexistent directory name\n");
+			return 1;
+		}
+		/* Clean test directory */
+		errno = 0;
+		if (remove_dir_recursive(argv[i]) < 0) {
+			fprintf(stderr, "Error in remove_dir_recursive() errno: %d\n", errno);
+			return 1;
+		}
+	}
+
+	fprintf(stderr, "Clean successful\n");
+	return 0;
+}

fs_mark/test.yaml

@@ -0,0 +1,13 @@
+test:
+  type: harness
+  harness: fs_mark.py
+  #targets:
+    #value: [ia32-generic-qemu, armv7a7-imx6ull-evk, armv7a9-zynq7000-qemu, armv7a9-zynq7000-zedboard]
+
+  tests:
+    - name: test1
+      execute: fs_mark -d /tmp/1 -s 0 -n 1 -v -k -S 0
+    - name: test2
+      execute: fs_mark -d /tmp/2 -s 5 -n 10 -v -k -S 0
+    - name: test3
+      execute: fs_mark -d /tmp/3 -s 100 -n 500 -v -k -S 0

fs_mark/timing_data.py

@@ -0,0 +1,40 @@
+# Timing ranges used in fs_mark harness
+
+timing_dict = {
+    ('ia32-generic-qemu', 'creatMin'): (0, 90000),
+    ('ia32-generic-qemu', 'creatAvg'): (0, 90000),
+    ('ia32-generic-qemu', 'creatMax'): (0, 90000),
+    ('ia32-generic-qemu', 'writeMin'): (0, 90000),
+    ('ia32-generic-qemu', 'writeAvg'): (0, 90000),
+    ('ia32-generic-qemu', 'writeMax'): (0, 90000),
+    ('ia32-generic-qemu', 'closeMin'): (0, 90000),
+    ('ia32-generic-qemu', 'closeAvg'): (0, 90000),
+    ('ia32-generic-qemu', 'closeMax'): (0, 90000),
+    ('armv7a9-zynq7000-zedboard', 'creatMin'): (2000, 5000),
+    ('armv7a9-zynq7000-zedboard', 'creatAvg'): (2000, 5000),
+    ('armv7a9-zynq7000-zedboard', 'creatMax'): (0, 0),
+    ('armv7a9-zynq7000-zedboard', 'writeMin'): (0, 0),
+    ('armv7a9-zynq7000-zedboard', 'writeAvg'): (0, 0),
+    ('armv7a9-zynq7000-zedboard', 'writeMax'): (0, 0),
+    ('armv7a9-zynq7000-zedboard', 'closeMin'): (0, 0),
+    ('armv7a9-zynq7000-zedboard', 'closeAvg'): (0, 0),
+    ('armv7a9-zynq7000-zedboard', 'closeMax'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'creatMin'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'creatAvg'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'creatMax'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'writeMin'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'writeAvg'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'writeMax'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'closeMin'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'closeAvg'): (0, 0),
+    ('armv7a9-zynq7000-qemu', 'closeMax'): (0, 0),
+    ('armv7a7-imx6ull-evk', 'creatMin'): (500, 5000),
+    ('armv7a7-imx6ull-evk', 'creatAvg'): (500, 5000),
+    ('armv7a7-imx6ull-evk', 'creatMax'): (500, 7000),
+    ('armv7a7-imx6ull-evk', 'writeMin'): (500, 20000),
+    ('armv7a7-imx6ull-evk', 'writeAvg'): (500, 30000),
+    ('armv7a7-imx6ull-evk', 'writeMax'): (500, 40000),
+    ('armv7a7-imx6ull-evk', 'closeMin'): (30, 500),
+    ('armv7a7-imx6ull-evk', 'closeAvg'): (30, 500),
+    ('armv7a7-imx6ull-evk', 'closeMax'): (30, 500)
+}