[LTP] [PATCH V2 01/14] mem/lib: convert to new API

Li Wang liwang@redhat.com
Mon Apr 10 12:05:43 CEST 2017


Add new SAFE_READ_MEMINFO macro to replace function read_meminfo().

Signed-off-by: Li Wang <liwang@redhat.com>
---
 include/tst_safe_file_ops.h        |   6 +
 testcases/kernel/mem/include/mem.h |   9 +-
 testcases/kernel/mem/lib/mem.c     | 314 ++++++++++++++++---------------------
 3 files changed, 141 insertions(+), 188 deletions(-)

diff --git a/include/tst_safe_file_ops.h b/include/tst_safe_file_ops.h
index 4d19877..5c3fea4 100644
--- a/include/tst_safe_file_ops.h
+++ b/include/tst_safe_file_ops.h
@@ -38,6 +38,12 @@
 	file_lines_scanf(__FILE__, __LINE__, NULL, 1,\
 			(path), (fmt), ## __VA_ARGS__)
 
+#define SAFE_READ_MEMINFO(item) \
+       ({long tst_rval; \
+        SAFE_FILE_LINES_SCANF("/proc/meminfo", item " %ld", \
+                        &tst_rval); \
+        tst_rval;})
+
 #define FILE_PRINTF(path, fmt, ...) \
 	file_printf(__FILE__, __LINE__, \
 		    (path), (fmt), ## __VA_ARGS__)
diff --git a/testcases/kernel/mem/include/mem.h b/testcases/kernel/mem/include/mem.h
index f9522a5..377cc55 100644
--- a/testcases/kernel/mem/include/mem.h
+++ b/testcases/kernel/mem/include/mem.h
@@ -1,7 +1,7 @@
 #ifndef _MEM_H
 #define _MEM_H
 #include "config.h"
-#include "test.h"
+#include "tst_test.h"
 
 #if defined(__powerpc__) || defined(__powerpc64__)
 #define MAXNODES		256
@@ -84,16 +84,13 @@ void mount_mem(char *name, char *fs, char *options, char *path, char *path_new);
 void umount_mem(char *path, char *path_new);
 
 /* shared */
-unsigned int get_a_numa_node(void (*cleanup_fn)(void));
+unsigned int get_a_numa_node(void);
 int  path_exist(const char *path, ...);
-long read_meminfo(char *item);
 void set_sys_tune(char *sys_file, long tune, int check);
 long get_sys_tune(char *sys_file);
-void cleanup(void);
-void setup(void);
 
 void update_shm_size(size_t *shm_size);
 
 /* MMAP */
-int range_is_mapped(void (*cleanup_fn) (void), unsigned long low, unsigned long high);
+int range_is_mapped(unsigned long low, unsigned long high);
 #endif
diff --git a/testcases/kernel/mem/lib/mem.c b/testcases/kernel/mem/lib/mem.c
index 7e403b5..053737b 100644
--- a/testcases/kernel/mem/lib/mem.c
+++ b/testcases/kernel/mem/lib/mem.c
@@ -1,9 +1,12 @@
+#define TST_NO_DEFAULT_MAIN
+
 #include "config.h"
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <sys/param.h>
 #include <errno.h>
 #include <fcntl.h>
 #if HAVE_NUMA_H
@@ -16,10 +19,9 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include <unistd.h>
 
-#include "test.h"
-#include "safe_macros.h"
 #include "mem.h"
 #include "numa_helper.h"
 
@@ -31,7 +33,7 @@ static int alloc_mem(long int length, int testcase)
 	long i, pagesz = getpagesize();
 	int loop = 10;
 
-	tst_resm(TINFO, "thread (%lx), allocating %ld bytes.",
+	tst_res(TINFO, "thread (%lx), allocating %ld bytes.",
 		(unsigned long) pthread_self(), length);
 
 	s = mmap(NULL, length, PROT_READ | PROT_WRITE,
@@ -80,7 +82,7 @@ static void child_alloc(int testcase, int lite, int threads)
 
 	th = malloc(sizeof(pthread_t) * threads);
 	if (!th) {
-		tst_resm(TINFO | TERRNO, "malloc");
+		tst_res(TINFO | TERRNO, "malloc");
 		goto out;
 	}
 
@@ -88,7 +90,7 @@ static void child_alloc(int testcase, int lite, int threads)
 		TEST(pthread_create(&th[i], NULL, child_alloc_thread,
 			(void *)((long)testcase)));
 		if (TEST_RETURN) {
-			tst_resm(TINFO | TRERRNO, "pthread_create");
+			tst_res(TINFO | TRERRNO, "pthread_create");
 			/*
 			 * Keep going if thread other than first fails to
 			 * spawn due to lack of resources.
@@ -125,13 +127,13 @@ void oom(int testcase, int lite, int retcode, int allow_sigkill)
 	pid_t pid;
 	int status, threads;
 
-	switch (pid = fork()) {
+	switch (pid = SAFE_FORK()) {
 	case -1:
 		if (errno == retcode) {
-			tst_resm(TPASS | TERRNO, "fork");
+			tst_res(TPASS | TERRNO, "fork");
 			return;
 		}
-		tst_brkm(TBROK | TERRNO, cleanup, "fork");
+		tst_brk(TBROK | TERRNO, "fork");
 	case 0:
 		threads = MAX(1, tst_ncpus() - 1);
 		child_alloc(testcase, lite, threads);
@@ -139,31 +141,30 @@ void oom(int testcase, int lite, int retcode, int allow_sigkill)
 		break;
 	}
 
-	tst_resm(TINFO, "expected victim is %d.", pid);
-	if (waitpid(-1, &status, 0) == -1)
-		tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
+	tst_res(TINFO, "expected victim is %d.", pid);
+	SAFE_WAITPID(-1, &status, 0);
 
 	if (WIFSIGNALED(status)) {
 		if (allow_sigkill && WTERMSIG(status) == SIGKILL) {
-			tst_resm(TPASS, "victim signalled: (%d) %s",
+			tst_res(TPASS, "victim signalled: (%d) %s",
 				SIGKILL,
 				tst_strsig(SIGKILL));
 		} else {
-			tst_resm(TFAIL, "victim signalled: (%d) %s",
+			tst_res(TFAIL, "victim signalled: (%d) %s",
 				WTERMSIG(status),
 				tst_strsig(WTERMSIG(status)));
 		}
 	} else if (WIFEXITED(status)) {
 		if (WEXITSTATUS(status) == retcode) {
-			tst_resm(TPASS, "victim retcode: (%d) %s",
+			tst_res(TPASS, "victim retcode: (%d) %s",
 				retcode, strerror(retcode));
 		} else {
-			tst_resm(TFAIL, "victim unexpectedly ended with "
+			tst_res(TFAIL, "victim unexpectedly ended with "
 				"retcode: %d, expected: %d",
 				WEXITSTATUS(status), retcode);
 		}
 	} else {
-		tst_resm(TFAIL, "victim unexpectedly ended");
+		tst_res(TFAIL, "victim unexpectedly ended");
 	}
 }
 
@@ -178,10 +179,9 @@ static void set_global_mempolicy(int mempolicy)
 	if (mempolicy) {
 		ret = get_allowed_nodes_arr(NH_MEMS|NH_CPUS, &num_nodes, &nodes);
 		if (ret != 0)
-			tst_brkm(TBROK|TERRNO, cleanup,
-				 "get_allowed_nodes_arr");
+			tst_brk(TBROK|TERRNO, "get_allowed_nodes_arr");
 		if (num_nodes < 2) {
-			tst_resm(TINFO, "mempolicy need NUMA system support");
+			tst_res(TINFO, "mempolicy need NUMA system support");
 			free(nodes);
 			return;
 		}
@@ -193,7 +193,7 @@ static void set_global_mempolicy(int mempolicy)
 		case MPOL_INTERLEAVE:
 		case MPOL_PREFERRED:
 			if (num_nodes == 2) {
-				tst_resm(TINFO, "The mempolicy need "
+				tst_res(TINFO, "The mempolicy need "
 					 "more than 2 numa nodes");
 				free(nodes);
 				return;
@@ -204,10 +204,10 @@ static void set_global_mempolicy(int mempolicy)
 			}
 			break;
 		default:
-			tst_brkm(TBROK|TERRNO, cleanup, "Bad mempolicy mode");
+			tst_brk(TBROK|TERRNO, "Bad mempolicy mode");
 		}
 		if (set_mempolicy(mempolicy, nmask, MAXNODES) == -1)
-			tst_brkm(TBROK|TERRNO, cleanup, "set_mempolicy");
+			tst_brk(TBROK|TERRNO, "set_mempolicy");
 	}
 #endif
 }
@@ -218,10 +218,10 @@ void testoom(int mempolicy, int lite, int retcode, int allow_sigkill)
 
 	set_global_mempolicy(mempolicy);
 
-	tst_resm(TINFO, "start normal OOM testing.");
+	tst_res(TINFO, "start normal OOM testing.");
 	oom(NORMAL, lite, retcode, allow_sigkill);
 
-	tst_resm(TINFO, "start OOM testing for mlocked pages.");
+	tst_res(TINFO, "start OOM testing for mlocked pages.");
 	oom(MLOCK, lite, retcode, allow_sigkill);
 
 	/*
@@ -229,14 +229,14 @@ void testoom(int mempolicy, int lite, int retcode, int allow_sigkill)
 	 * run to run, which isn't reliable for oom03 cgroup test.
 	 */
 	if (access(PATH_KSM, F_OK) == -1 || lite == 1) {
-		tst_resm(TINFO, "KSM is not configed or lite == 1, "
+		tst_res(TINFO, "KSM is not configed or lite == 1, "
 			 "skip OOM test for KSM pags");
 	} else {
-		tst_resm(TINFO, "start OOM testing for KSM pages.");
-		SAFE_FILE_SCANF(cleanup, PATH_KSM "run", "%d", &ksm_run_orig);
-		SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1");
+		tst_res(TINFO, "start OOM testing for KSM pages.");
+		SAFE_FILE_SCANF(PATH_KSM "run", "%d", &ksm_run_orig);
+		SAFE_FILE_PRINTF(PATH_KSM "run", "1");
 		oom(KSM, lite, retcode, allow_sigkill);
-		SAFE_FILE_PRINTF(cleanup,PATH_KSM "run", "%d", ksm_run_orig);
+		SAFE_FILE_PRINTF(PATH_KSM "run", "%d", ksm_run_orig);
 	}
 }
 
@@ -247,8 +247,8 @@ static int max_page_sharing;
 void save_max_page_sharing(void)
 {
 	if (access(PATH_KSM "max_page_sharing", F_OK) == 0)
-	        SAFE_FILE_SCANF(NULL, PATH_KSM "max_page_sharing",
-	                        "%d", &max_page_sharing);
+		SAFE_FILE_SCANF(PATH_KSM "max_page_sharing",
+				"%d", &max_page_sharing);
 }
 
 void restore_max_page_sharing(void)
@@ -264,11 +264,11 @@ static void check(char *path, long int value)
 	long actual_val;
 
 	snprintf(fullpath, BUFSIZ, PATH_KSM "%s", path);
-	SAFE_FILE_SCANF(cleanup, fullpath, "%ld", &actual_val);
+	SAFE_FILE_SCANF(fullpath, "%ld", &actual_val);
 
-	tst_resm(TINFO, "%s is %ld.", path, actual_val);
+	tst_res(TINFO, "%s is %ld.", path, actual_val);
 	if (actual_val != value)
-		tst_resm(TFAIL, "%s is not %ld.", path, value);
+		tst_res(TFAIL, "%s is not %ld.", path, value);
 }
 
 static void wait_ksmd_done(void)
@@ -282,17 +282,10 @@ static void wait_ksmd_done(void)
 		sleep(10);
 		count++;
 
-		SAFE_FILE_SCANF(cleanup, PATH_KSM "pages_shared",
-				"%ld", &pages_shared);
-
-		SAFE_FILE_SCANF(cleanup, PATH_KSM "pages_sharing",
-				"%ld", &pages_sharing);
-
-		SAFE_FILE_SCANF(cleanup, PATH_KSM "pages_volatile",
-				"%ld", &pages_volatile);
-
-		SAFE_FILE_SCANF(cleanup, PATH_KSM "pages_unshared",
-				"%ld", &pages_unshared);
+		SAFE_FILE_SCANF(PATH_KSM "pages_shared", "%ld", &pages_shared);
+		SAFE_FILE_SCANF(PATH_KSM "pages_sharing", "%ld", &pages_sharing);
+		SAFE_FILE_SCANF(PATH_KSM "pages_volatile", "%ld", &pages_volatile);
+		SAFE_FILE_SCANF(PATH_KSM "pages_unshared", "%ld", &pages_unshared);
 
 		if (pages_shared != old_pages_shared ||
 		    pages_sharing != old_pages_sharing ||
@@ -307,7 +300,7 @@ static void wait_ksmd_done(void)
 		}
 	}
 
-	tst_resm(TINFO, "ksm daemon takes %ds to scan all mergeable pages",
+	tst_res(TINFO, "ksm daemon takes %ds to scan all mergeable pages",
 		 count * 10);
 }
 
@@ -318,7 +311,7 @@ static void group_check(int run, int pages_shared, int pages_sharing,
 	/* wait for ksm daemon to scan all mergeable pages. */
 	wait_ksmd_done();
 
-	tst_resm(TINFO, "check!");
+	tst_res(TINFO, "check!");
 	check("run", run);
 	check("pages_shared", pages_shared);
 	check("pages_sharing", pages_sharing);
@@ -334,18 +327,16 @@ static void verify(char **memory, char value, int proc,
 	int i, j;
 	void *s = NULL;
 
-	s = malloc((end - start) * (end2 - start2));
-	if (s == NULL)
-		tst_brkm(TBROK | TERRNO, tst_exit, "malloc");
+	s = SAFE_MALLOC((end - start) * (end2 - start2));
 
-	tst_resm(TINFO, "child %d verifies memory content.", proc);
+	tst_res(TINFO, "child %d verifies memory content.", proc);
 	memset(s, value, (end - start) * (end2 - start2));
 	if (memcmp(memory[start], s, (end - start) * (end2 - start2))
 	    != 0)
 		for (j = start; j < end; j++)
 			for (i = start2; i < end2; i++)
 				if (memory[j][i] != value)
-					tst_resm(TFAIL, "child %d has %c at "
+					tst_res(TFAIL, "child %d has %c at "
 						 "%d,%d,%d.",
 						 proc, memory[j][i], proc,
 						 j, i);
@@ -354,9 +345,9 @@ static void verify(char **memory, char value, int proc,
 
 void write_memcg(void)
 {
-	SAFE_FILE_PRINTF(NULL, MEMCG_LIMIT, "%ld", TESTMEM);
+	SAFE_FILE_PRINTF(MEMCG_LIMIT, "%ld", TESTMEM);
 
-	SAFE_FILE_PRINTF(NULL, MEMCG_PATH_NEW "/tasks", "%d", getpid());
+	SAFE_FILE_PRINTF(MEMCG_PATH_NEW "/tasks", "%d", getpid());
 }
 
 struct ksm_merge_data {
@@ -370,14 +361,14 @@ static void ksm_child_memset(int child_num, int size, int total_unit,
 	int i = 0, j;
 	int unit = size / total_unit;
 
-	tst_resm(TINFO, "child %d continues...", child_num);
+	tst_res(TINFO, "child %d continues...", child_num);
 
 	if (ksm_merge_data.mergeable_size == size * MB) {
-		tst_resm(TINFO, "child %d allocates %d MB filled with '%c'",
+		tst_res(TINFO, "child %d allocates %d MB filled with '%c'",
 			child_num, size, ksm_merge_data.data);
 
 	} else {
-		tst_resm(TINFO, "child %d allocates %d MB filled with '%c'"
+		tst_res(TINFO, "child %d allocates %d MB filled with '%c'"
 				" except one page with 'e'",
 				child_num, size, ksm_merge_data.data);
 	}
@@ -404,21 +395,19 @@ static void create_ksm_child(int child_num, int size, int unit,
 	total_unit = size / unit;
 
 	/* Apply for the space for memory */
-	memory = malloc(total_unit * sizeof(char *));
+	memory = SAFE_MALLOC(total_unit * sizeof(char *));
 	for (j = 0; j < total_unit; j++) {
-		memory[j] = mmap(NULL, unit * MB, PROT_READ|PROT_WRITE,
+		memory[j] = SAFE_MMAP(NULL, unit * MB, PROT_READ|PROT_WRITE,
 			MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-		if (memory[j] == MAP_FAILED)
-			tst_brkm(TBROK|TERRNO, tst_exit, "mmap");
 #ifdef HAVE_MADV_MERGEABLE
 		if (madvise(memory[j], unit * MB, MADV_MERGEABLE) == -1)
-			tst_brkm(TBROK|TERRNO, tst_exit, "madvise");
+			tst_brk(TBROK|TERRNO, "madvise");
 #endif
 	}
 
-	tst_resm(TINFO, "child %d stops.", child_num);
+	tst_res(TINFO, "child %d stops.", child_num);
 	if (raise(SIGSTOP) == -1)
-		tst_brkm(TBROK|TERRNO, tst_exit, "kill");
+		tst_brk(TBROK|TERRNO, "kill");
 	fflush(stdout);
 
 	for (j = 0; j < 4; j++) {
@@ -428,9 +417,9 @@ static void create_ksm_child(int child_num, int size, int unit,
 
 		fflush(stdout);
 
-		tst_resm(TINFO, "child %d stops.", child_num);
+		tst_res(TINFO, "child %d stops.", child_num);
 		if (raise(SIGSTOP) == -1)
-			tst_brkm(TBROK|TERRNO, tst_exit, "kill");
+			tst_brk(TBROK|TERRNO, "kill");
 
 		if (ksm_merge_data[j].mergeable_size < size * MB) {
 			verify(memory, 'e', child_num, total_unit - 1,
@@ -443,19 +432,18 @@ static void create_ksm_child(int child_num, int size, int unit,
 		}
 	}
 
-	tst_resm(TINFO, "child %d finished.", child_num);
+	tst_res(TINFO, "child %d finished.", child_num);
 }
 
 static void stop_ksm_children(int *child, int num)
 {
 	int k, status;
 
-	tst_resm(TINFO, "wait for all children to stop.");
+	tst_res(TINFO, "wait for all children to stop.");
 	for (k = 0; k < num; k++) {
-		if (waitpid(child[k], &status, WUNTRACED) == -1)
-			tst_brkm(TBROK|TERRNO, cleanup, "waitpid");
+		SAFE_WAITPID(child[k], &status, WUNTRACED);
 		if (!WIFSTOPPED(status))
-			tst_brkm(TBROK, cleanup, "child %d was not stopped", k);
+			tst_brk(TBROK, "child %d was not stopped", k);
 	}
 }
 
@@ -463,11 +451,10 @@ static void resume_ksm_children(int *child, int num)
 {
 	int k;
 
-	tst_resm(TINFO, "resume all children.");
-	for (k = 0; k < num; k++) {
-		if (kill(child[k], SIGCONT) == -1)
-			tst_brkm(TBROK|TERRNO, cleanup, "kill child[%d]", k);
-	}
+	tst_res(TINFO, "resume all children.");
+	for (k = 0; k < num; k++)
+		SAFE_KILL(child[k], SIGCONT);
+
 	fflush(stdout);
 }
 
@@ -501,15 +488,11 @@ void create_same_memory(int size, int num, int unit)
 		}
 	}
 
-	child = malloc(num * sizeof(int));
-	if (child == NULL)
-		tst_brkm(TBROK | TERRNO, cleanup, "malloc");
+	child = SAFE_MALLOC(num * sizeof(int));
 
 	for (i = 0; i < num; i++) {
 		fflush(stdout);
-		switch (child[i] = fork()) {
-		case -1:
-			tst_brkm(TBROK|TERRNO, cleanup, "fork");
+		switch (child[i] = SAFE_FORK()) {
 		case 0:
 			if (i == 0) {
 				create_ksm_child(i, size, unit, ksm_data0);
@@ -529,14 +512,12 @@ void create_same_memory(int size, int num, int unit)
 
 	stop_ksm_children(child, num);
 
-	tst_resm(TINFO, "KSM merging...");
+	tst_res(TINFO, "KSM merging...");
 	if (access(PATH_KSM "max_page_sharing", F_OK) == 0)
-		SAFE_FILE_PRINTF(cleanup, PATH_KSM "max_page_sharing",
-				"%ld", size * pages * num);
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "pages_to_scan", "%ld",
-			 size * pages * num);
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "sleep_millisecs", "0");
+		SAFE_FILE_PRINTF(PATH_KSM "max_page_sharing", "%ld", size * pages * num);
+	SAFE_FILE_PRINTF(PATH_KSM "run", "1");
+	SAFE_FILE_PRINTF(PATH_KSM "pages_to_scan", "%ld", size * pages * num);
+	SAFE_FILE_PRINTF(PATH_KSM "sleep_millisecs", "0");
 
 	resume_ksm_children(child, num);
 	group_check(1, 2, size * num * pages - 2, 0, 0, 0, size * pages * num);
@@ -555,19 +536,19 @@ void create_same_memory(int size, int num, int unit)
 
 	stop_ksm_children(child, num);
 
-	tst_resm(TINFO, "KSM unmerging...");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2");
+	tst_res(TINFO, "KSM unmerging...");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "2");
 
 	resume_ksm_children(child, num);
 	group_check(2, 0, 0, 0, 0, 0, size * pages * num);
 
-	tst_resm(TINFO, "stop KSM.");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "0");
+	tst_res(TINFO, "stop KSM.");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "0");
 	group_check(0, 0, 0, 0, 0, 0, size * pages * num);
 
 	while (waitpid(-1, &status, WUNTRACED | WCONTINUED) > 0)
 		if (WEXITSTATUS(status) != 0)
-			tst_resm(TFAIL, "child exit status is %d",
+			tst_res(TFAIL, "child exit status is %d",
 				 WEXITSTATUS(status));
 }
 
@@ -586,9 +567,9 @@ void test_ksm_merge_across_nodes(unsigned long nr_pages)
 
 	ret = get_allowed_nodes_arr(NH_MEMS|NH_CPUS, &num_nodes, &nodes);
 	if (ret != 0)
-		tst_brkm(TBROK|TERRNO, cleanup, "get_allowed_nodes_arr");
+		tst_brk(TBROK|TERRNO, "get_allowed_nodes_arr");
 	if (num_nodes < 2) {
-		tst_resm(TINFO, "need NUMA system support");
+		tst_res(TINFO, "need NUMA system support");
 		free(nodes);
 		return;
 	}
@@ -596,15 +577,13 @@ void test_ksm_merge_across_nodes(unsigned long nr_pages)
 	pagesize = sysconf(_SC_PAGE_SIZE);
 	length = nr_pages * pagesize;
 
-	memory = malloc(num_nodes * sizeof(char *));
+	memory = SAFE_MALLOC(num_nodes * sizeof(char *));
 	for (i = 0; i < num_nodes; i++) {
-		memory[i] = mmap(NULL, length, PROT_READ|PROT_WRITE,
+		memory[i] = SAFE_MMAP(NULL, length, PROT_READ|PROT_WRITE,
 			    MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-		if (memory[i] == MAP_FAILED)
-			tst_brkm(TBROK|TERRNO, tst_exit, "mmap");
 #ifdef HAVE_MADV_MERGEABLE
 		if (madvise(memory[i], length, MADV_MERGEABLE) == -1)
-			tst_brkm(TBROK|TERRNO, tst_exit, "madvise");
+			tst_brk(TBROK|TERRNO, "madvise");
 #endif
 
 #if HAVE_NUMA_H && HAVE_LINUX_MEMPOLICY_H && HAVE_NUMAIF_H \
@@ -617,17 +596,17 @@ void test_ksm_merge_across_nodes(unsigned long nr_pages)
 		 */
 		ret = mbind(memory[i], length, MPOL_BIND, nmask, MAXNODES, 0);
 		if (ret == -1)
-			tst_brkm(TBROK|TERRNO, tst_exit, "mbind");
+			tst_brk(TBROK|TERRNO, "mbind");
 #endif
 
 		memset(memory[i], 10, length);
 	}
 
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "sleep_millisecs", "0");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "pages_to_scan", "%ld",
+	SAFE_FILE_PRINTF(PATH_KSM "sleep_millisecs", "0");
+	SAFE_FILE_PRINTF(PATH_KSM "pages_to_scan", "%ld",
 			 nr_pages * num_nodes);
 	if (access(PATH_KSM "max_page_sharing", F_OK) == 0)
-		SAFE_FILE_PRINTF(cleanup, PATH_KSM "max_page_sharing",
+		SAFE_FILE_PRINTF(PATH_KSM "max_page_sharing",
 			"%ld", nr_pages * num_nodes);
 	/*
 	 * merge_across_nodes setting can be changed only when there
@@ -635,23 +614,23 @@ void test_ksm_merge_across_nodes(unsigned long nr_pages)
 	 * pages first, then to 1 after changing merge_across_nodes,
 	 * to remerge according to the new setting.
 	 */
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "2");
 	wait_ksmd_done();
-	tst_resm(TINFO, "Start to test KSM with merge_across_nodes=1");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "merge_across_nodes", "1");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1");
+	tst_res(TINFO, "Start to test KSM with merge_across_nodes=1");
+	SAFE_FILE_PRINTF(PATH_KSM "merge_across_nodes", "1");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "1");
 	group_check(1, 1, nr_pages * num_nodes - 1, 0, 0, 0,
 		    nr_pages * num_nodes);
 
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "2");
 	wait_ksmd_done();
-	tst_resm(TINFO, "Start to test KSM with merge_across_nodes=0");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "merge_across_nodes", "0");
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1");
+	tst_res(TINFO, "Start to test KSM with merge_across_nodes=0");
+	SAFE_FILE_PRINTF(PATH_KSM "merge_across_nodes", "0");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "1");
 	group_check(1, num_nodes, nr_pages * num_nodes - num_nodes,
 		    0, 0, 0, nr_pages * num_nodes);
 
-	SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2");
+	SAFE_FILE_PRINTF(PATH_KSM "run", "2");
 	wait_ksmd_done();
 }
 
@@ -660,22 +639,22 @@ void check_ksm_options(int *size, int *num, int *unit)
 	if (opt_size) {
 		*size = atoi(opt_sizestr);
 		if (*size < 1)
-			tst_brkm(TBROK, cleanup, "size cannot be less than 1.");
+			tst_brk(TBROK, "size cannot be less than 1.");
 	}
 	if (opt_unit) {
 		*unit = atoi(opt_unitstr);
 		if (*unit > *size)
-			tst_brkm(TBROK, cleanup,
+			tst_brk(TBROK,
 				 "unit cannot be greater than size.");
 		if (*size % *unit != 0)
-			tst_brkm(TBROK, cleanup,
+			tst_brk(TBROK,
 				 "the remainder of division of size by unit is "
 				 "not zero.");
 	}
 	if (opt_num) {
 		*num = atoi(opt_numstr);
 		if (*num < 3)
-			tst_brkm(TBROK, cleanup,
+			tst_brk(TBROK,
 				 "process number cannot be less 3.");
 	}
 }
@@ -712,7 +691,7 @@ static void gather_node_cpus(char *cpus, long nd)
 			 * be taken offline
 			 */
 			if (path_exist(path1)) {
-				SAFE_FILE_SCANF(cleanup, path1, "%ld", &online);
+				SAFE_FILE_SCANF(path1, "%ld", &online);
 				if (online == 0)
 					continue;
 			}
@@ -742,13 +721,12 @@ void read_cpuset_files(char *prefix, char *filename, char *retbuf)
 				 prefix, filename);
 			fd = open(path, O_RDONLY);
 			if (fd == -1)
-				tst_brkm(TBROK | TERRNO, cleanup,
-					 "open %s", path);
+				tst_brk(TBROK | TERRNO, "open %s", path);
 		} else
-			tst_brkm(TBROK | TERRNO, cleanup, "open %s", path);
+			tst_brk(TBROK | TERRNO, "open %s", path);
 	}
 	if (read(fd, retbuf, BUFSIZ) < 0)
-		tst_brkm(TBROK | TERRNO, cleanup, "read %s", path);
+		tst_brk(TBROK | TERRNO, "read %s", path);
 	close(fd);
 }
 
@@ -770,13 +748,11 @@ void write_cpuset_files(char *prefix, char *filename, char *buf)
 				 prefix, filename);
 			fd = open(path, O_WRONLY);
 			if (fd == -1)
-				tst_brkm(TBROK | TERRNO, cleanup,
-					 "open %s", path);
+				tst_brk(TBROK | TERRNO, "open %s", path);
 		} else
-			tst_brkm(TBROK | TERRNO, cleanup, "open %s", path);
+			tst_brk(TBROK | TERRNO, "open %s", path);
 	}
-	if (write(fd, buf, strlen(buf)) != (ssize_t)strlen(buf))
-		tst_brkm(TBROK | TERRNO, cleanup, "write %s", path);
+	SAFE_WRITE(1, fd, buf, strlen(buf));
 	close(fd);
 }
 
@@ -797,12 +773,12 @@ void write_cpusets(long nd)
 	if (strlen(cpus) != 0) {
 		write_cpuset_files(CPATH_NEW, "cpus", cpus);
 	} else {
-		tst_resm(TINFO, "No CPUs in the node%ld; "
+		tst_res(TINFO, "No CPUs in the node%ld; "
 				"using only CPU0", nd);
 		write_cpuset_files(CPATH_NEW, "cpus", "0");
 	}
 
-	SAFE_FILE_PRINTF(NULL, CPATH_NEW "/tasks", "%d", getpid());
+	SAFE_FILE_PRINTF(CPATH_NEW "/tasks", "%d", getpid());
 }
 
 void umount_mem(char *path, char *path_new)
@@ -815,53 +791,51 @@ void umount_mem(char *path, char *path_new)
 	sprintf(s, "%s/tasks", path);
 	fd = open(s, O_WRONLY);
 	if (fd == -1)
-		tst_resm(TWARN | TERRNO, "open %s", s);
+		tst_res(TWARN | TERRNO, "open %s", s);
 
 	snprintf(s_new, BUFSIZ, "%s/tasks", path_new);
 	fp = fopen(s_new, "r");
 	if (fp == NULL)
-		tst_resm(TWARN | TERRNO, "fopen %s", s_new);
+		tst_res(TWARN | TERRNO, "fopen %s", s_new);
 	if ((fd != -1) && (fp != NULL)) {
 		while (fgets(value, BUFSIZ, fp) != NULL)
 			if (write(fd, value, strlen(value) - 1)
 			    != (ssize_t)strlen(value) - 1)
-				tst_resm(TWARN | TERRNO, "write %s", s);
+				tst_res(TWARN | TERRNO, "write %s", s);
 	}
 	if (fd != -1)
 		close(fd);
 	if (fp != NULL)
 		fclose(fp);
 	if (rmdir(path_new) == -1)
-		tst_resm(TWARN | TERRNO, "rmdir %s", path_new);
+		tst_res(TWARN | TERRNO, "rmdir %s", path_new);
 	if (umount(path) == -1)
-		tst_resm(TWARN | TERRNO, "umount %s", path);
+		tst_res(TWARN | TERRNO, "umount %s", path);
 	if (rmdir(path) == -1)
-		tst_resm(TWARN | TERRNO, "rmdir %s", path);
+		tst_res(TWARN | TERRNO, "rmdir %s", path);
 }
 
 void mount_mem(char *name, char *fs, char *options, char *path, char *path_new)
 {
-	if (mkdir(path, 0777) == -1)
-		tst_brkm(TBROK | TERRNO, cleanup, "mkdir %s", path);
+	SAFE_MKDIR(path, 0777);
 	if (mount(name, path, fs, 0, options) == -1) {
 		if (errno == ENODEV) {
 			if (rmdir(path) == -1)
-				tst_resm(TWARN | TERRNO, "rmdir %s failed",
+				tst_res(TWARN | TERRNO, "rmdir %s failed",
 					 path);
-			tst_brkm(TCONF, NULL,
+			tst_brk(TCONF,
 				 "file system %s is not configured in kernel",
 				 fs);
 		}
-		tst_brkm(TBROK | TERRNO, cleanup, "mount %s", path);
+		tst_brk(TBROK | TERRNO, "mount %s", path);
 	}
-	if (mkdir(path_new, 0777) == -1)
-		tst_brkm(TBROK | TERRNO, cleanup, "mkdir %s", path_new);
+	SAFE_MKDIR(path_new, 0777);
 }
 
 /* shared */
 
 /* Warning: *DO NOT* use this function in child */
-unsigned int get_a_numa_node(void (*cleanup_fn) (void))
+unsigned int get_a_numa_node(void)
 {
 	unsigned int nd1, nd2;
 	int ret;
@@ -871,24 +845,24 @@ unsigned int get_a_numa_node(void (*cleanup_fn) (void))
 	case 0:
 		break;
 	case -3:
-		tst_brkm(TCONF, cleanup_fn, "requires a NUMA system.");
+		tst_brk(TCONF, "requires a NUMA system.");
 	default:
-		tst_brkm(TBROK | TERRNO, cleanup_fn, "1st get_allowed_nodes");
+		tst_brk(TBROK | TERRNO, "1st get_allowed_nodes");
 	}
 
 	ret = get_allowed_nodes(NH_MEMS | NH_CPUS, 1, &nd1);
 	switch (ret) {
 	case 0:
-		tst_resm(TINFO, "get node%u.", nd1);
+		tst_res(TINFO, "get node%u.", nd1);
 		return nd1;
 	case -3:
-		tst_brkm(TCONF, cleanup_fn, "requires a NUMA system that has "
+		tst_brk(TCONF, "requires a NUMA system that has "
 			 "at least one node with both memory and CPU "
 			 "available.");
 	default:
 		break;
 	}
-	tst_brkm(TBROK | TERRNO, cleanup_fn, "2nd get_allowed_nodes");
+	tst_brk(TBROK | TERRNO, "2nd get_allowed_nodes");
 }
 
 int path_exist(const char *path, ...)
@@ -903,44 +877,20 @@ int path_exist(const char *path, ...)
 	return access(pathbuf, F_OK) == 0;
 }
 
-long read_meminfo(char *item)
-{
-	FILE *fp;
-	char line[BUFSIZ], buf[BUFSIZ];
-	long val;
-
-	fp = fopen(PATH_MEMINFO, "r");
-	if (fp == NULL)
-		tst_brkm(TBROK | TERRNO, cleanup, "fopen %s", PATH_MEMINFO);
-
-	while (fgets(line, BUFSIZ, fp) != NULL) {
-		if (sscanf(line, "%64s %ld", buf, &val) == 2)
-			if (strcmp(buf, item) == 0) {
-				fclose(fp);
-				return val;
-			}
-		continue;
-	}
-	fclose(fp);
-
-	tst_brkm(TBROK, cleanup, "cannot find \"%s\" in %s",
-		 item, PATH_MEMINFO);
-}
-
 void set_sys_tune(char *sys_file, long tune, int check)
 {
 	long val;
 	char path[BUFSIZ];
 
-	tst_resm(TINFO, "set %s to %ld", sys_file, tune);
+	tst_res(TINFO, "set %s to %ld", sys_file, tune);
 
 	snprintf(path, BUFSIZ, PATH_SYSVM "%s", sys_file);
-	SAFE_FILE_PRINTF(NULL, path, "%ld", tune);
+	SAFE_FILE_PRINTF(path, "%ld", tune);
 
 	if (check) {
 		val = get_sys_tune(sys_file);
 		if (val != tune)
-			tst_brkm(TBROK, cleanup, "%s = %ld, but expect %ld",
+			tst_brk(TBROK, "%s = %ld, but expect %ld",
 				 sys_file, val, tune);
 	}
 }
@@ -951,7 +901,7 @@ long get_sys_tune(char *sys_file)
 	long tune;
 
 	snprintf(path, BUFSIZ, PATH_SYSVM "%s", sys_file);
-	SAFE_FILE_SCANF(NULL, path, "%ld", &tune);
+	SAFE_FILE_SCANF(path, "%ld", &tune);
 
 	return tune;
 }
@@ -960,20 +910,20 @@ void update_shm_size(size_t * shm_size)
 {
 	size_t shmmax;
 
-	SAFE_FILE_SCANF(cleanup, PATH_SHMMAX, "%ld", &shmmax);
+	SAFE_FILE_SCANF(PATH_SHMMAX, "%ld", &shmmax);
 	if (*shm_size > shmmax) {
-		tst_resm(TINFO, "Set shm_size to shmmax: %ld", shmmax);
+		tst_res(TINFO, "Set shm_size to shmmax: %ld", shmmax);
 		*shm_size = shmmax;
 	}
 }
 
-int range_is_mapped(void (*cleanup_fn) (void), unsigned long low, unsigned long high)
+int range_is_mapped(unsigned long low, unsigned long high)
 {
 	FILE *fp;
 
 	fp = fopen("/proc/self/maps", "r");
 	if (fp == NULL)
-		tst_brkm(TBROK | TERRNO, cleanup_fn, "Failed to open /proc/self/maps.");
+		tst_brk(TBROK | TERRNO, "Failed to open /proc/self/maps.");
 
 	while (!feof(fp)) {
 		unsigned long start, end;
@@ -982,7 +932,7 @@ int range_is_mapped(void (*cleanup_fn) (void), unsigned long low, unsigned long
 		ret = fscanf(fp, "%lx-%lx %*[^\n]\n", &start, &end);
 		if (ret != 2) {
 			fclose(fp);
-			tst_brkm(TBROK | TERRNO, cleanup_fn, "Couldn't parse /proc/self/maps line.");
+			tst_brk(TBROK | TERRNO, "Couldn't parse /proc/self/maps line.");
 		}
 
 		if ((start >= low) && (start < high)) {
-- 
2.9.3



More information about the ltp mailing list