Improved mount test

ROMFS/px4fmu_test/init.d/rcS

@@ -2,6 +2,7 @@
 #
 # PX4FMU startup script for test hackery.
 #
+uorb start
 
 if sercon
 then
@@ -26,10 +27,51 @@ else
 	tone_alarm error
 fi
 
+#
+# Start a minimal system
+#
+
+if [ -f /etc/extras/px4io-v2_default.bin ]
+then
+	set io_file /etc/extras/px4io-v2_default.bin
+else
+	set io_file /etc/extras/px4io-v1_default.bin
+fi
+
+if px4io start
+then
+	echo "PX4IO OK"
+fi
+
+if px4io checkcrc $io_file
+then
+	echo "PX4IO CRC OK"
+else
+	echo "PX4IO CRC failure"
+	tone_alarm MBABGP
+	if px4io forceupdate 14662 $io_file
+	then
+		usleep 500000
+		if px4io start
+		then
+			echo "PX4IO restart OK"
+			tone_alarm MSPAA
+		else
+			echo "PX4IO restart failed"
+			tone_alarm MNGGG
+			sleep 5
+			reboot
+		fi
+	else
+		echo "PX4IO update failed"
+		tone_alarm MNGGG
+	fi
+fi
+
 #
 # The presence of this file suggests we're running a mount stress test
 #
-if [ -f /fs/microsd/mount_test_cmds ]
+if [ -f /fs/microsd/mount_test_cmds.txt ]
 then
 	tests mount
 fi

makefiles/config_px4fmu-v2_test.mk

@@ -6,14 +6,18 @@
 # Use the configuration's ROMFS.
 #
 ROMFS_ROOT	 = $(PX4_BASE)/ROMFS/px4fmu_test
+ROMFS_OPTIONAL_FILES = $(PX4_BASE)/Images/px4io-v2_default.bin
 
 #
 # Board support modules
 #
 MODULES		+= drivers/device
 MODULES		+= drivers/stm32
+MODULES		+= drivers/stm32/adc
+MODULES		+= drivers/stm32/tone_alarm
 MODULES		+= drivers/led
 MODULES		+= drivers/boards/px4fmu-v2
+MODULES		+= drivers/px4io
 MODULES		+= systemcmds/perf
 MODULES		+= systemcmds/reboot
 MODULES		+= systemcmds/tests

src/systemcmds/tests/test_file.c

@@ -103,6 +103,7 @@ test_file(int argc, char *argv[])
 					if ((0x3 & (uintptr_t)(write_buf + a)))
 						errx(1, "memory is unaligned, align shift: %d", a);
 
+					return 1;
 				}
 
 				fsync(fd);
@@ -139,7 +140,8 @@ test_file(int argc, char *argv[])
 				}
 
 				if (!compare_ok) {
-					errx(1, "ABORTING FURTHER COMPARISON DUE TO ERROR");
+					warnx("ABORTING FURTHER COMPARISON DUE TO ERROR");
+					return 1;
 				}
 
 			}
@@ -266,70 +268,3 @@ test_file(int argc, char *argv[])
 
 	return 0;
 }
-#if 0
-int
-test_file(int argc, char *argv[])
-{
-	const iterations = 1024;
-
-	/* check if microSD card is mounted */
-	struct stat buffer;
-	if (stat("/fs/microsd/", &buffer)) {
-		warnx("no microSD card mounted, aborting file test");
-		return 1;
-	}
-
-	uint8_t buf[512];
-	hrt_abstime start, end;
-	perf_counter_t wperf = perf_alloc(PC_ELAPSED, "SD writes");
-
-	int fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
-	memset(buf, 0, sizeof(buf));
-
-	start = hrt_absolute_time();
-	for (unsigned i = 0; i < iterations; i++) {
-		perf_begin(wperf);
-		write(fd, buf, sizeof(buf));
-		perf_end(wperf);
-	}
-	end = hrt_absolute_time();
-
-	close(fd);
-
-	unlink("/fs/microsd/testfile");
-
-	warnx("%dKiB in %llu microseconds", iterations / 2, end - start);
-	perf_print_counter(wperf);
-	perf_free(wperf);
-
-	warnx("running unlink test");
-
-	/* ensure that common commands do not run against file count limits */
-	for (unsigned i = 0; i < 64; i++) {
-
-		warnx("unlink iteration #%u", i);
-
-		int fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
-		if (fd < 0)
-			errx(1, "failed opening test file before unlink()");
-		int ret = write(fd, buf, sizeof(buf));
-		if (ret < 0)
-			errx(1, "failed writing test file before unlink()");
-		close(fd);
-
-		ret = unlink("/fs/microsd/testfile");
-		if (ret != OK)
-			errx(1, "failed unlinking test file");
-
-		fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
-		if (fd < 0)
-			errx(1, "failed opening test file after unlink()");
-		ret = write(fd, buf, sizeof(buf));
-		if (ret < 0)
-			errx(1, "failed writing test file after unlink()");
-		close(fd);
-	}
-
-	return 0;
-}
-#endif

src/systemcmds/tests/test_mount.c

@@ -46,6 +46,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <systemlib/err.h>
+#include <systemlib/systemlib.h>
 #include <systemlib/perf_counter.h>
 #include <string.h>
 
@@ -53,11 +54,17 @@
 
 #include "tests.h"
 
+const int fsync_tries = 50;
+const int abort_tries = 200;
+
 int
 test_mount(int argc, char *argv[])
 {
-	const unsigned iterations = 100;
+	const unsigned iterations = 10;
-	const unsigned alignments = 65;
+	const unsigned alignments = 4;
+
+	const char* cmd_filename = "/fs/microsd/mount_test_cmds.txt";
+
 
 	/* check if microSD card is mounted */
 	struct stat buffer;
@@ -66,56 +73,114 @@ test_mount(int argc, char *argv[])
 		return 1;
 	}
 
+	/* list directory */
+	DIR		*d;
+	struct dirent	*dir;
+	d = opendir("/fs/microsd");
+	if (d) {
+
+		while ((dir = readdir(d)) != NULL) {
+			//printf("%s\n", dir->d_name);
+		}
+
+		closedir(d);
+
+		warnx("directory listing ok (FS mounted and readable)");
+
+	} else {
+		/* failed opening dir */
+		warnx("FAILED LISTING MICROSD ROOT DIRECTORY");
+
+		if (stat(cmd_filename, &buffer) == OK) {
+			(void)unlink(cmd_filename);
+		}
+
+		return 1;
+	}
+
 	/* read current test status from file, write test instructions for next round */
-	const char* cmd_filename = "/fs/microsd/mount_test_cmds";
 
 	/* initial values */
-	int it_left_fsync = 100;
+	int it_left_fsync = fsync_tries;
-	int it_left_abort = 100;
+	int it_left_abort = abort_tries;
 
 	int cmd_fd;
-	if (stat(cmd_filename, &buffer)) {
+	if (stat(cmd_filename, &buffer) == OK) {
 
 		/* command file exists, read off state */
-		cmd_fd = open(cmd_filename, O_RDWR);
+		cmd_fd = open(cmd_filename, O_RDWR | O_NONBLOCK);
 		char buf[64];
 		int ret = read(cmd_fd, buf, sizeof(buf));
-		if (ret > 0)
-			ret = sscanf("%d %d", &it_left_fsync, &it_left_abort);
 
-		warnx("Iterations left: #%d / #%d\n(%s)", it_left_fsync, it_left_abort, buf);
+		if (ret > 0) {
+			int count = 0;
+			ret = sscanf(buf, "TEST: %u %u %n", &it_left_fsync, &it_left_abort, &count);
+		} else {
+			buf[0] = '\0';
+		}
+
+		if (it_left_fsync > fsync_tries)
+			it_left_fsync = fsync_tries;
+
+		if (it_left_abort > abort_tries)
+			it_left_abort = abort_tries;
+
+		warnx("Iterations left: #%d / #%d of %d / %d\n(%s)", it_left_fsync, it_left_abort,
+			fsync_tries, abort_tries, buf);
+
+		int it_left_fsync_prev = it_left_fsync;
 
 		/* now write again what to do next */
 		if (it_left_fsync > 0)
 			it_left_fsync--;
-		if (it_left_fsync == 0 && it_left_abort > 0)
+
+		if (it_left_fsync == 0 && it_left_abort > 0) {
+
 			it_left_abort--;
 
-		if (it_left_abort == 0)
+			/* announce mode switch */
+			if (it_left_fsync_prev != it_left_fsync && it_left_fsync == 0) {
+				warnx("\n SUCCESSFULLY PASSED FSYNC'ED WRITES, CONTINUTING WITHOUT FSYNC");
+				fsync(stdout);
+				fsync(stderr);
+				usleep(20000);
+			}
+
+		}
+
+		if (it_left_abort == 0) {
 			(void)unlink(cmd_filename);
 			return 0;
+		}
 
 	} else {
 
 		/* this must be the first iteration, do something */
 		cmd_fd = open(cmd_filename, O_TRUNC | O_WRONLY | O_CREAT);
+
+		warnx("First iteration of file test\n");
 	}
 
 	char buf[64];
-	sprintf(buf, "%d %d", it_left_fsync, it_left_abort);
+	int wret = sprintf(buf, "TEST: %d %d ", it_left_fsync, it_left_abort);
+	lseek(cmd_fd, 0, SEEK_SET);
 	write(cmd_fd, buf, strlen(buf) + 1);
+	fsync(cmd_fd);
 
 	/* perform tests for a range of chunk sizes */
-	unsigned chunk_sizes[] = {1, 5, 8, 13, 16, 32};
+	unsigned chunk_sizes[] = {32, 64, 128, 256, 512, 600, 1200};
 
 	for (unsigned c = 0; c < (sizeof(chunk_sizes) / sizeof(chunk_sizes[0])); c++) {
 
-		printf("\n====== FILE TEST: %u bytes chunks ======\n", chunk_sizes[c]);
+		printf("\n\n====== FILE TEST: %u bytes chunks (%s) ======\n", chunk_sizes[c], (it_left_fsync > 0) ? "FSYNC" : "NO FSYNC");
+		fsync(stdout);
+		fsync(stderr);
+		usleep(50000);
 
 		for (unsigned a = 0; a < alignments; a++) {
 
-			printf("\n");
+			// warnx("----- alignment test: %u bytes -----", a);
-			warnx("----- alignment test: %u bytes -----", a);
+			printf(".");
 
 			uint8_t write_buf[chunk_sizes[c] + alignments] __attribute__((aligned(64)));
 
@@ -127,15 +192,12 @@ test_mount(int argc, char *argv[])
 
 			uint8_t read_buf[chunk_sizes[c] + alignments] __attribute__((aligned(64)));
 			hrt_abstime start, end;
-			//perf_counter_t wperf = perf_alloc(PC_ELAPSED, "SD writes (aligned)");
 
 			int fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
 
-			warnx("testing unaligned writes - please wait..");
-
 			start = hrt_absolute_time();
 			for (unsigned i = 0; i < iterations; i++) {
-				//perf_begin(wperf);
+
 				int wret = write(fd, write_buf + a, chunk_sizes[c]);
 
 				if (wret != chunk_sizes[c]) {
@@ -144,25 +206,23 @@ test_mount(int argc, char *argv[])
 					if ((0x3 & (uintptr_t)(write_buf + a)))
 						errx(1, "memory is unaligned, align shift: %d", a);
 
+					return 1;
+
 				}
 
 				if (it_left_fsync > 0) {
 					fsync(fd);
 				} else {
-					if (it_left_abort % chunk_sizes[c] == 0) {
+					if (it_left_abort % 5 == 0) {
-						systemreset();
+						systemreset(false);
+					} else {
+						fsync(stdout);
+						fsync(stderr);
 					}
 				}
-				//perf_end(wperf);
-
 			}
 			end = hrt_absolute_time();
 
-			//warnx("%dKiB in %llu microseconds", iterations / 2, end - start);
-
-			//perf_print_counter(wperf);
-			//perf_free(wperf);
-
 			close(fd);
 			fd = open("/fs/microsd/testfile", O_RDONLY);
 
@@ -204,28 +264,18 @@ test_mount(int argc, char *argv[])
 		}
 	}
 
-	/* list directory */
+	fsync(stdout);
-	DIR		*d;
+	fsync(stderr);
-	struct dirent	*dir;
+	usleep(20000);
-	d = opendir("/fs/microsd");
-	if (d) {
 
-		while ((dir = readdir(d)) != NULL) {
-			//printf("%s\n", dir->d_name);
-		}
 
-		closedir(d);
-
-		warnx("directory listing ok (FS mounted and readable)");
-
-	} else {
-		/* failed opening dir */
-		warnx("FAILED LISTING MICROSD ROOT DIRECTORY");
-		return 1;
-	}
 
 	/* we always reboot for the next test if we get here */
-	systemreset();
+	warnx("Iteration done, rebooting..");
+	fsync(stdout);
+	fsync(stderr);
+	usleep(50000);
+	systemreset(false);
 
 	/* never going to get here */
 	return 0;