freestanding improvements (exit, function checks)

Fixed exit for freestanding (as assert now uses it).
Running each function check now in a forked process so they can be killed or return other exit codes (and so each function runs, even if others crash)

vlib/builtin/bare/.checks/linuxsys/linuxsys.v

@@ -1,7 +1,5 @@
 module main
-
-__global fd [2]int
-__global buffer [128]byte
+import forkedtest
 
 const (
 	sample_text_file1 = ""
@@ -15,7 +13,7 @@ fn check_fork_minimal () {
 		sys_exit(ec)
 	}
 	siginfo := [
-		int(0), 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
 		0, 0, 0, 0, 0, 0, 0, 0,
 		0, 0, 0, 0, 0, 0, 0, 0,
 		0, 0, 0, 0, 0, 0, 0, 0,
@@ -27,14 +25,12 @@ fn check_fork_minimal () {
 	e := sys_waitid(.p_pid, child, intptr(siginfo.data) , .wexited, 0)
 
 	assert e == .enoerror
-	//println(i64_tos(buffer,80,siginfo[sig_index.si_code],16))
+	//println(i64_tos(buffer0,80,siginfo[sig_index.si_code],16))
 	assert siginfo[sig_index.si_code] == int(wi_si_code.cld_exited)
 	assert siginfo[sig_index.si_pid] == child
 	assert siginfo[sig_index.si_status] == ec
 	assert siginfo[sig_index.si_signo] == int(signo.sigchld)
 	assert siginfo[sig_index.si_uid] == sys_getuid()
-
-	println("fork minimal check passed")
 }
 
 fn check_read_write_pipe() {
@@ -44,14 +40,15 @@ fn check_read_write_pipe() {
 	//		sys_read
 	//		sys_close
 	//
-	println ("checking pipe read/write")
-	fd[0] = -1
-	fd[1] = -1
+	buffer, e := mm_alloc(128)
+	assert e == .enoerror
+
+	fd := [-1, -1]
 
 	assert fd[0] == -1
 	assert fd[1] == -1
 
-	a := sys_pipe(intptr(fd))
+	a := sys_pipe(intptr(fd.data))
 
 	assert a == .enoerror
 
@@ -81,7 +78,7 @@ fn check_read_write_pipe() {
 
 	assert sys_close(-1) == .ebadf
 
-	println ("pipe read/write passed")
+	assert mm_free(buffer) == .enoerror
 }
 
 fn check_read_file() {
@@ -92,9 +89,11 @@ fn check_read_file() {
 			sys_close
 			sys_open
 	*/
+	buffer, mae := mm_alloc(128)
+	assert mae == .enoerror
+
 	test_file := "sample_text1.txt"
 	sample_text := "Do not change this text.\n"
-	println ("checking read file")
 	fd, ec := sys_open(test_file.str, .o_rdonly, 0)
 	assert fd > 0
 	assert ec == .enoerror
@@ -106,16 +105,13 @@ fn check_read_file() {
 		assert sample_text[i] == buffer[i]
 	}
 	assert sys_close(fd) == .enoerror
-
-	println("read file passed")
+	assert mm_free(buffer) == .enoerror
 }
 
 fn check_open_file_fail() {
-	println ("checking 'open file fail'")
 	fd1, ec1 := sys_open("./nofilehere".str, .o_rdonly, 0)
 	assert fd1 == -1
 	assert ec1 == .enoent
-	println ("'open file fail' check passed")
 }
 
 /*
@@ -133,19 +129,11 @@ fn check_print() {
 */
 
 fn check_munmap_fail() {
-	println ("checking 'munmap fail'")
-
 	ec := sys_munmap(-16384,8192)
 	assert ec == .einval
-	//es := i64_tos(buffer2,80,int(ec),16)
-	//println(es)
-
-	println ("'munmap fail' check passed")
 }
 
 fn check_mmap_one_page() {
-	println ("checking check_mmap_one_page")
-
 	mp := int(mm_prot.prot_read) | int(mm_prot.prot_write)
 	mf := int(map_flags.map_private) | int(map_flags.map_anonymous)
 	mut a, e := sys_mmap(0, u64(linux_mem.page_size), mm_prot(mp), map_flags(mf), -1, 0)
@@ -161,12 +149,9 @@ fn check_mmap_one_page() {
 
 	ec := sys_munmap(a, u64(linux_mem.page_size))
 	assert ec == .enoerror
-
-	println ("check_mmap_one_page passed")
 }
 
 fn check_mm_pages() {
-	println ("checking check_mm_pages")
 	for i in 0 .. int(linux_mem.page_size)-4 {
 		assert u32(1) == mm_pages(u64(i))
 	}
@@ -176,24 +161,16 @@ fn check_mm_pages() {
 	for i in (int(linux_mem.page_size)*2)-3 .. (int(linux_mem.page_size)*3)-4 {
 		assert u32(3) == mm_pages(u64(i))
 	}
-	println ("check_mm_pages passed")
 }
 
 //pub fn mm_alloc(size u64) (voidptr, errno)
 
 fn check_mm_alloc() {
-	println ("checking mm_alloc")
-
 	for i in 1 .. 2000 {
 		size := u64(i*1000)
 		pages := mm_pages(size)
 		mut a, e := mm_alloc(size)
 
-		//ads := i64_tos(buffer,80,i64(a),16)
-		//println(ads)
-		//es := i64_tos(buffer,80,i64(e),16)
-		//println(es)
-
 		assert e == .enoerror
 		ap := intptr(a-4)
 		assert *ap == int(pages)
@@ -210,27 +187,20 @@ fn check_mm_alloc() {
 
 		mfa := mm_free(a)
 
-		//mfas := i64_tos(buffer,80,i64(mfa),16)
-		//println(mfas)
-
 		assert mfa == .enoerror
 	}
-	println ("mm_alloc passed")
 }
 
 fn check_int_array_ro() {
-	println ("trying check_int_array_ro")
 	a := [100,110,120,130]
 	assert a.len == 4
 	assert a[0] == 100
 	assert a[1] == 110
 	assert a[2] == 120
 	assert a[3] == 130
-	println ("check_int_array_ro passed")
 }
 
 fn check_int_array_rw() {
-	println ("trying check_int_array_rw")
 	mut a := [-10,-11,-12,-13]
 	assert a.len == 4
 	assert a[0] == -10
@@ -243,12 +213,9 @@ fn check_int_array_rw() {
 		assert a[i] == b
 	}
 	assert a[3] == 130
-
-	println ("check_int_array_rw passed")
 }
 
 fn check_int64_array_ro() {
-	println ("trying check_int64_array_ro")
 	a := [i64(1000),1100,1200,1300,1400]
 	assert a.len == 5
 	assert a[0] == 1000
@@ -256,11 +223,9 @@ fn check_int64_array_ro() {
 	assert a[2] == 1200
 	assert a[3] == 1300
 	assert a[4] == 1400
-	println ("check_int64_array_ro passed")
 }
 
 fn check_voidptr_array_ro() {
-	println ("trying check_voidptr_array_ro")
 	a := [
 		voidptr(10000),
 		voidptr(11000),
@@ -276,11 +241,9 @@ fn check_voidptr_array_ro() {
 	assert a[3] == voidptr(13000)
 	assert a[4] == voidptr(14000)
 	assert a[5] == voidptr(15000)
-	println ("check_voidptr_array_ro passed")
 }
 
 fn check_voidptr_array_rw() {
-	println ("trying check_voidptr_array_rw")
 	mut a := [
 		voidptr(-1),
 		voidptr(-1),
@@ -315,24 +278,26 @@ fn check_voidptr_array_rw() {
 
 	a[5] = voidptr(150000)
 	assert a[5] == voidptr(150000)
-	println ("check_voidptr_array_rw passed")
 }
 
 
 fn main() {
-	check_read_write_pipe()
-	check_read_file()
+	mut fails := 0
+	fails += forkedtest.normal_run(check_fork_minimal, "check_fork_minimal")
+	fails += forkedtest.normal_run(check_munmap_fail, "check_munmap_fail")
+	fails += forkedtest.normal_run(check_mmap_one_page, "check_mmap_one_page")
+	fails += forkedtest.normal_run(check_mm_pages, "check_mm_pages")
+	fails += forkedtest.normal_run(check_mm_alloc, "check_mm_alloc")
+	fails += forkedtest.normal_run(check_read_write_pipe, "check_read_write_pipe")
+	fails += forkedtest.normal_run(check_read_file, "check_read_file")
 	// check_print()
-	check_open_file_fail()
-	check_munmap_fail()
-	check_mmap_one_page()
-	check_mm_pages()
-	check_mm_alloc()
-	check_int_array_ro()
-	check_int_array_rw()
-	check_int64_array_ro()
-	check_voidptr_array_ro()
-	check_voidptr_array_rw()
-	check_fork_minimal()
+	fails += forkedtest.normal_run(check_open_file_fail, "check_open_file_fail")
+	fails += forkedtest.normal_run(check_int_array_ro, "check_int_array_ro")
+	fails += forkedtest.normal_run(check_int_array_rw, "check_int_array_rw")
+	fails += forkedtest.normal_run(check_int64_array_ro, "check_int64_array_ro")
+	fails += forkedtest.normal_run(check_voidptr_array_ro, "check_voidptr_array_ro")
+	fails += forkedtest.normal_run(check_voidptr_array_rw, "check_voidptr_array_rw")
+
+	assert fails == 0
 	sys_exit(0)
 }