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,185 @@
+import trunner
+import time
+import os
+import yaml
+import re
+import pexpect
+import timing_data as t_data
+import psh.tools.psh as psh
+
+from datetime import datetime
+from trunner.ctx import TestContext
+from trunner.dut import Dut
+from trunner.types import TestResult, TestSubResult, Status
+
+# Targets with dummyfs
+dummy_list = ['armv7m7-imxrt105x-evk', 'armv7m7-imxrt106x-evk',
+              'armv7m7-imxrt117x-evk', 'armv7m4-stm32l4x6-nucleo']
+
+
+def clean(dut, test_name, ctx: TestContext):
+    global dirs
+
+    if ctx.target.name in dummy_list:
+        return
+
+    if '-k' in test_name or '-L' in test_name or '-F' in test_name:
+        args = test_name.split()
+        args = args[1:]
+
+        def get_dir(x):
+            if args[x[0] - 1] == '-d':
+                return x[1]
+
+        dirs = list(map(lambda x: get_dir(x), enumerate(args)))
+        dirs = [x for x in dirs if x is not None]
+
+        dut.expect(re.escape(ctx.target.shell_prompt), timeout=10)
+        psh._send(dut, f'/bin/fs_mark_clean {" ".join(dirs)}')
+        dut.expect(re.escape(ctx.target.shell_prompt), timeout=1800)
+
+
+def harness(dut: Dut, ctx: TestContext, result: TestResult):
+    target = trunner.ctx.target.name
+    logs_path = '~/remote/logs/fs_mark_logs'
+    test_status = Status.OK
+
+    subresult = None
+    test_name = None
+    got_time = False
+    first_loop = True
+
+    f_use = None
+    count = None
+    size = None
+    files_sec = None
+    app_overhead = None
+
+    start_time = None
+    end_time = None
+    loop_time = 600
+
+    NAME = r".+?#  (?P<name>(/bin/)?fs_mark.+?)\r+\n"
+    MSG_LINE = r"(?P<line>(\s+\d+){3}.+?)\r+\n"
+    FINAL = r"(?P<final>Insufficient free space.+?)\r+\n"
+    END = r"(?P<end>Average Files/sec:.+?)\r+\n"
+    END2 = r".+?(?P<end2>ENOMEM|EIO|ENOSPC|Error in remove_dir_recursive).+?"
+    END3 = r".+?(?P<end2>Error in remove_dir_recursive).+?"
+
+    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,
+                END2
+            ], timeout=loop_time)
+            parsed = dut.match.groupdict()
+
+        except pexpect.TIMEOUT:
+            test_status = Status.FAIL
+            subresult = TestSubResult(name=str(test_name), msg='Timeout, probably fs hang-up', status=Status.FAIL)
+            result.add_subresult_obj(subresult)
+            clean(dut, test_name, ctx)
+            break
+
+        if idx == 0:
+            test_name = parsed["name"]
+            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(os.path.expanduser(logs_path), 'a') as file:
+            #         if first_loop is True:
+            #             first_loop = False
+            #             file.write(test_name + ' ' + str(datetime.now()) + '\n')
+            #         else:
+            #             file.write('\n')
+            #         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"
+                result.add_subresult_obj(subresult)
+                subresult = None
+                clean(dut, test_name, ctx)
+                break
+
+        elif 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
+            clean(dut, test_name, ctx)
+            break
+        elif idx == 2:
+            if got_time is False:
+                subresult = TestSubResult(name=str(test_name), status=Status.FAIL)
+                subresult.msg += "\n\tInsufficient free space"
+                result.add_subresult_obj(subresult)
+                subresult = None
+            clean(dut, test_name, ctx)
+            break
+        elif idx == 4:
+            # test_status = Status.FAIL
+            if got_time is False:
+                subresult = TestSubResult(name=str(test_name), status=Status.FAIL)
+                subresult.msg += "\n\tEIO"
+                result.add_subresult_obj(subresult)
+                subresult = None
+            clean(dut, test_name, ctx)
+            break
+        elif idx == 5:
+            # test_status = Status.FAIL
+            if got_time is False:
+                subresult = TestSubResult(name=str(test_name), status=Status.FAIL)
+                subresult.msg += "\n\tError while cleaning"
+                result.add_subresult_obj(subresult)
+                subresult = None
+            clean(dut, test_name, ctx)
+            break
+
+    return TestResult(status=test_status)

fs_mark/fs_mark_clean.c

@@ -0,0 +1,76 @@
+/*
+ * 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) {
+		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 == DT_DIR ? remove_dir_recursive : remove;
+			if (remove_func(filename) != 0) {
+				closedir(dir);
+				return -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;
+}