[PATCH 1/6] added outputerr/outputstd log functions

[PATCH 1/6] added outputerr/outputstd log functions

[Ildar Muslukhov]

Signed-off-by: Ildar Muslukhov <ildarm@google.com>

---
 include/log.h |  2 ++
 log.c         | 22 ++++++++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/include/log.h b/include/log.h
index 2497988..7041eda 100644
--- a/include/log.h
+++ b/include/log.h
@@ -25,6 +25,8 @@
 unsigned int highest_logfile(void);
 void synclogs(void);
 void output(unsigned char level, const char *fmt, ...);
+void outputerr(const char *fmt, ...);
+void outputstd(const char *fmt, ...);
 void open_logfiles(void);
 void close_logfiles(void);
 
diff --git a/log.c b/log.c
index 850a3e2..144567a 100644
--- a/log.c
+++ b/log.c
@@ -221,3 +221,25 @@ void output(unsigned char level, const char *fmt, ...)
 	fprintf(handle, "%s %s", prefix, monobuf);
 	(void)fflush(handle);
 }
+
+/*
+* Used as a way to consolidated all printf calls if someones one to redirect it to somewhere else.
+* note: this function ignores quiet_level since it main purpose is error output.
+*/
+void outputerr(const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	vfprintf(stderr, fmt, args);
+	va_end(args);
+}
+
+void outputstd(const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	vfprintf(stdout, fmt, args);
+	va_end(args);
+}
-- 
1.8.4

[PATCH 2/6] wired outputstd/err functions

[Ildar Muslukhov]

Signed-off-by: Ildar Muslukhov <ildarm@google.com>

---
 child.c                    |  4 +--
 children/random-syscalls.c |  2 +-
 generic-sanitise.c         |  2 +-
 ioctls/ioctls.c            | 19 +++++++-------
 log.c                      | 18 ++++++-------
 main.c                     |  8 +++---
 maps.c                     |  8 +++---
 net/protocols.c            |  7 ++---
 params.c                   | 50 ++++++++++++++++++------------------
 pids.c                     |  4 +--
 seed.c                     |  4 +--
 sockets.c                  |  6 ++---
 syscalls/perf_event_open.c |  7 ++---
 tables.c                   | 64 +++++++++++++++++++++++-----------------------
 trinity.c                  | 18 ++++++-------
 15 files changed, 112 insertions(+), 109 deletions(-)

diff --git a/child.c b/child.c
index e52fbab..e203aeb 100644
--- a/child.c
+++ b/child.c
@@ -50,7 +50,7 @@ static void reenable_coredumps(void)
 	prctl(PR_SET_DUMPABLE, TRUE);
 
 	if (setrlimit(RLIMIT_CORE, &oldrlimit) != 0) {
-		printf("[%d] Error restoring rlimits to cur:%d max:%d (%s)\n",
+		outputerr("[%d] Error restoring rlimits to cur:%d max:%d (%s)\n",
 			getpid(),
 			(unsigned int) oldrlimit.rlim_cur,
 			(unsigned int) oldrlimit.rlim_max,
@@ -72,7 +72,7 @@ static void set_make_it_fail(void)
 
 	if (write(fd, buf, 1) == -1) {
 		if (errno != EPERM)
-			printf("writing to /proc/self/make-it-fail failed! (%s)\n", strerror(errno));
+			outputerr("writing to /proc/self/make-it-fail failed! (%s)\n", strerror(errno));
 		else
 			shm->do_make_it_fail = TRUE;
 	}
diff --git a/children/random-syscalls.c b/children/random-syscalls.c
index 08d2f76..8f8d770 100644
--- a/children/random-syscalls.c
+++ b/children/random-syscalls.c
@@ -112,7 +112,7 @@ int child_random_syscalls(int childno)
 		}
 
 		if (shm->exit_reason != STILL_RUNNING) {
-			printf("Main is not running, exiting");
+			outputerr("Main is not running, exiting");
 			goto out;
 		}
 
diff --git a/generic-sanitise.c b/generic-sanitise.c
index a2fe9ad..e64f3dd 100644
--- a/generic-sanitise.c
+++ b/generic-sanitise.c
@@ -91,7 +91,7 @@ static unsigned long handle_arg_range(unsigned int call, unsigned int argnum)
 	}
 
 	if (high == 0) {
-		printf("%s forgets to set hirange!\n", syscalls[call].entry->name);
+		outputerr("%s forgets to set hirange!\n", syscalls[call].entry->name);
 		BUG("Fix syscall definition!\n");
 		return 0;
 	}
diff --git a/ioctls/ioctls.c b/ioctls/ioctls.c
index 76cf550..e43bc3c 100644
--- a/ioctls/ioctls.c
+++ b/ioctls/ioctls.c
@@ -4,6 +4,7 @@
 #include <stdio.h>
 
 #include "trinity.h"	// ARRAY_SIZE
+#include "log.h"
 #include "files.h"
 #include "shm.h"
 #include "ioctls.h"
@@ -20,7 +21,7 @@ void register_ioctl_group(const struct ioctl_group *grp)
 		return;
 
 	if (grps_cnt == ARRAY_SIZE(grps)) {
-		fprintf(stderr, "WARNING: please grow IOCTL_GROUPS_MAX.\n");
+		outputerr("WARNING: please grow IOCTL_GROUPS_MAX.\n");
 		return;
 	}
 
@@ -100,24 +101,24 @@ void dump_ioctls(void)
 
 	for (i=0; i < grps_cnt; ++i) {
 		if (grps[i]->name)
-			printf("- %s:\n", grps[i]->name);
+			outputerr("- %s:\n", grps[i]->name);
 		else if (grps[i]->devtype) {
 			if (grps[i]->devtype == DEV_MISC)
-				printf("- misc devices");
+				outputerr("- misc devices");
 			else if (grps[i]->devtype == DEV_CHAR)
-				printf("- char devices");
+				outputerr("- char devices");
 			else if (grps[i]->devtype == DEV_BLOCK)
-				printf("- block devices");
+				outputerr("- block devices");
 			for (j=0; j < grps[i]->devs_cnt; ++j)
-				printf("%s '%s'",
+				outputerr("%s '%s'",
 					j == 0 ? "" : ",",
 					grps[i]->devs[j]);
-			printf(":\n");
+			outputerr(":\n");
 		} else
-			printf("- <unknown>:\n");
+			outputerr("- <unknown>:\n");
 
 		for (j=0; j < grps[i]->ioctls_cnt; ++j) {
-			printf("  - 0x%08x : %s\n",
+			outputerr("  - 0x%08x : %s\n",
 					grps[i]->ioctls[j].request,
 					grps[i]->ioctls[j].name ? : "");
 		}
diff --git a/log.c b/log.c
index 144567a..1298038 100644
--- a/log.c
+++ b/log.c
@@ -22,7 +22,7 @@ void open_logfiles(void)
 	unlink(logfilename);
 	mainlogfile = fopen(logfilename, "a");
 	if (!mainlogfile) {
-		printf("## couldn't open logfile %s\n", logfilename);
+		outputerr("## couldn't open logfile %s\n", logfilename);
 		exit(EXIT_FAILURE);
 	}
 
@@ -31,7 +31,7 @@ void open_logfiles(void)
 		unlink(logfilename);
 		shm->logfiles[i] = fopen(logfilename, "a");
 		if (!shm->logfiles[i]) {
-			printf("## couldn't open logfile %s\n", logfilename);
+			outputerr("## couldn't open logfile %s\n", logfilename);
 			exit(EXIT_FAILURE);
 		}
 	}
@@ -73,12 +73,12 @@ static FILE * find_logfile_handle(void)
 		if (i != PIDSLOT_NOT_FOUND)
 			return shm->logfiles[i];
 
-		printf("[%d] ## Couldn't find logfile for pid %d\n", getpid(), pid);
+		outputerr("## Couldn't find logfile for pid %d\n", pid);
 		dump_pid_slots();
-		printf("## Logfiles for pids: ");
+		outputerr("## Logfiles for pids: ");
 		for_each_pidslot(j)
-			printf("%p ", shm->logfiles[j]);
-		printf("\n");
+			outputerr("%p ", shm->logfiles[j]);
+		outputerr("\n");
 	}
 	return NULL;
 }
@@ -108,7 +108,7 @@ void synclogs(void)
 	for_each_pidslot(i) {
 		ret = fflush(shm->logfiles[i]);
 		if (ret == EOF) {
-			printf("## logfile flushing failed! %s\n", strerror(errno));
+			outputerr("## logfile flushing failed! %s\n", strerror(errno));
 			continue;
 		}
 
@@ -116,7 +116,7 @@ void synclogs(void)
 		if (fd != -1) {
 			ret = fsync(fd);
 			if (ret != 0)
-				printf("## fsyncing logfile %d failed. %s\n", i, strerror(errno));
+				outputerr("## fsyncing logfile %d failed. %s\n", i, strerror(errno));
 		}
 	}
 
@@ -172,7 +172,7 @@ void output(unsigned char level, const char *fmt, ...)
 	va_end(args);
 
 	if (n < 0) {
-		printf("## Something went wrong in output() [%d]\n", n);
+		outputerr("## Something went wrong in output() [%d]\n", n);
 		exit(EXIT_FAILURE);
 	}
 
diff --git a/main.c b/main.c
index ec2978d..0a1eba7 100644
--- a/main.c
+++ b/main.c
@@ -109,7 +109,7 @@ static void fork_children(void)
 		/* Find a space for it in the pid map */
 		pidslot = find_pid_slot(EMPTY_PIDSLOT);
 		if (pidslot == PIDSLOT_NOT_FOUND) {
-			printf("## Pid map was full!\n");
+			outputerr("## Pid map was full!\n");
 			dump_pid_slots();
 			exit(EXIT_FAILURE);
 		}
@@ -137,7 +137,7 @@ static void fork_children(void)
 				ret = pid_alive(mainpid);
 				if (ret != 0) {
 					shm->exit_reason = EXIT_SHM_CORRUPTION;
-					printf(BUGTXT "parent (%d) went away!\n", mainpid);
+					outputerr(BUGTXT "parent (%d) went away!\n", mainpid);
 					sleep(20000);
 				}
 			}
@@ -236,7 +236,7 @@ static void handle_child(pid_t childpid, int childstatus)
 			if (slot == PIDSLOT_NOT_FOUND) {
 				/* If we reaped it, it wouldn't show up, so check that. */
 				if (shm->last_reaped != childpid) {
-					printf("## Couldn't find pid slot for %d\n", childpid);
+					outputerr("## Couldn't find pid slot for %d\n", childpid);
 					shm->exit_reason = EXIT_LOST_PID_SLOT;
 					dump_pid_slots();
 				}
@@ -407,7 +407,7 @@ void do_main_loop(void)
 		while (pidmap_empty() == FALSE)
 			handle_children();
 
-		printf("Bailing main loop. Exit reason: %s\n", decode_exit(shm->exit_reason));
+		outputerr("Bailing main loop. Exit reason: %s\n", decode_exit(shm->exit_reason));
 		_exit(EXIT_SUCCESS);
 	}
 
diff --git a/maps.c b/maps.c
index 18b9bcb..c5d739b 100644
--- a/maps.c
+++ b/maps.c
@@ -39,7 +39,7 @@ static struct map * alloc_map(void)
 
 	newmap = malloc(sizeof(struct map));
 	if (!newmap) {
-		printf("Couldn't allocate maps list!\n");
+		outputerr("Couldn't allocate maps list!\n");
 		exit(EXIT_FAILURE);
 	}
 	memset(newmap, 0, sizeof(struct map));
@@ -70,7 +70,7 @@ static void * alloc_zero_map(struct map *map, int prot, const char *name)
 
 	fd = open("/dev/zero", O_RDWR);
 	if (fd < 0) {
-		printf("open /dev/zero failure. %s\n", strerror(errno));
+		outputerr("open /dev/zero failure. %s\n", strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
@@ -97,7 +97,7 @@ static void * alloc_zero_map(struct map *map, int prot, const char *name)
 	tmpmap->ptr = mmap(NULL, size, prot, MAP_ANONYMOUS|MAP_SHARED, fd, 0);
 
 	if (tmpmap->ptr == MAP_FAILED) {
-		printf("mmap /dev/zero failure\n");
+		outputerr("mmap /dev/zero failure\n");
 		exit(EXIT_FAILURE);
 	}
 
@@ -105,7 +105,7 @@ static void * alloc_zero_map(struct map *map, int prot, const char *name)
 
 	tmpmap->name = malloc(80);
 	if (!tmpmap->name) {
-		fprintf(stderr, "malloc() failed in %s().", __func__);
+		outputerr("malloc() failed in %s().", __func__);
 		exit(EXIT_FAILURE);
 	}
 
diff --git a/net/protocols.c b/net/protocols.c
index f42b762..3cec507 100644
--- a/net/protocols.c
+++ b/net/protocols.c
@@ -6,6 +6,7 @@
 #include "trinity.h"
 #include "constants.h"
 #include "net.h"
+#include "log.h"
 
 struct protocol {
 	const char *name;
@@ -89,10 +90,10 @@ void find_specific_proto(const char *protoarg)
 	}
 
 	if (i > TRINITY_PF_MAX) {
-		printf("Protocol unknown. Pass a numeric value [0-%d] or one of ", TRINITY_PF_MAX);
+		outputerr("Protocol unknown. Pass a numeric value [0-%d] or one of ", TRINITY_PF_MAX);
 		for (i = 0; i < ARRAY_SIZE(protocols); i++)
-			printf("%s ", protocols[i].name);
-		printf("\n");
+			outputerr("%s ", protocols[i].name);
+		outputerr("\n");
 
 		exit(EXIT_FAILURE);
 	}
diff --git a/params.c b/params.c
index 552742e..cde8684 100644
--- a/params.c
+++ b/params.c
@@ -54,28 +54,28 @@ bool kernel_taint_param_occured = FALSE;
 
 static void usage(void)
 {
-	fprintf(stderr, "%s\n", progname);
-	fprintf(stderr, " --children,-C: specify number of child processes\n");
-	fprintf(stderr, " --exclude,-x: don't call a specific syscall\n");
-	fprintf(stderr, " --group,-g: only run syscalls from a certain group (So far just 'vm').\n");
-	fprintf(stderr, " --kernel_taint, -T: controls which kernel taint flags should be considered, for more details refer to README file. \n");
-	fprintf(stderr, " --list,-L: list all syscalls known on this architecture.\n");
-	fprintf(stderr, " --ioctls,-I: list all ioctls.\n");
-	fprintf(stderr, " --logging,-l: (off=disable logging).\n");
-	fprintf(stderr, " --monochrome,-m: don't output ANSI codes\n");
-	fprintf(stderr, " --no_files,-n: Only pass sockets as fd's, not files\n");
-	fprintf(stderr, " --proto,-P: specify specific network protocol for sockets.\n");
-	fprintf(stderr, " --quiet,-q: less output.\n");
-	fprintf(stderr, " --random,-r#: pick N syscalls at random and just fuzz those\n");
-	fprintf(stderr, " --syslog,-S: log important info to syslog. (useful if syslog is remote)\n");
-	fprintf(stderr, " --verbose,-v: increase output verbosity.\n");
-	fprintf(stderr, " --victims,-V: path to victim files.\n");
-	fprintf(stderr, " --arch, -a: selects syscalls for the specified architecture (32 or 64). Both by default.");
-	fprintf(stderr, "\n");
-	fprintf(stderr, " -c#,@: target specific syscall (takes syscall name as parameter and optionally 32 or 64 as bit-width. Default:both).\n");
-	fprintf(stderr, " -N#: do # syscalls then exit.\n");
-	fprintf(stderr, " -p:  pause after syscall.\n");
-	fprintf(stderr, " -s#: use # as random seed.\n");
+	outputerr("%s\n", progname);
+	outputerr(" --children,-C: specify number of child processes\n");
+	outputerr(" --exclude,-x: don't call a specific syscall\n");
+	outputerr(" --group,-g: only run syscalls from a certain group (So far just 'vm').\n");
+	outputerr(" --kernel_taint, -T: controls which kernel taint flags should be considered, for more details refer to README file. \n");
+	outputerr(" --list,-L: list all syscalls known on this architecture.\n");
+	outputerr(" --ioctls,-I: list all ioctls.\n");
+	outputerr(" --logging,-l: (off=disable logging).\n");
+	outputerr(" --monochrome,-m: don't output ANSI codes\n");
+	outputerr(" --no_files,-n: Only pass sockets as fd's, not files\n");
+	outputerr(" --proto,-P: specify specific network protocol for sockets.\n");
+	outputerr(" --quiet,-q: less output.\n");
+	outputerr(" --random,-r#: pick N syscalls at random and just fuzz those\n");
+	outputerr(" --syslog,-S: log important info to syslog. (useful if syslog is remote)\n");
+	outputerr(" --verbose,-v: increase output verbosity.\n");
+	outputerr(" --victims,-V: path to victim files.\n");
+	outputerr(" --arch, -a: selects syscalls for the specified architecture (32 or 64). Both by default.");
+	outputerr("\n");
+	outputerr(" -c#,@: target specific syscall (takes syscall name as parameter and optionally 32 or 64 as bit-width. Default:both).\n");
+	outputerr(" -N#: do # syscalls then exit.\n");
+	outputerr(" -p:  pause after syscall.\n");
+	outputerr(" -s#: use # as random seed.\n");
 	exit(EXIT_SUCCESS);
 }
 
@@ -148,7 +148,7 @@ static void toggle_taint_flag_by_name(char *beg, char *end) {
 	else if (strcmp(name,"OOT_MODULE") == 0)
 		toggle_taint_flag(TAINT_OOT_MODULE);
 	else {
-		printf("Unrecognizable kernel taint flag \"%s\".\n", name);
+		outputerr("Unrecognizable kernel taint flag \"%s\".\n", name);
 		exit(EXIT_FAILURE);
 	}
 }
@@ -181,7 +181,7 @@ void parse_args(int argc, char *argv[])
 			if (opt == '?')
 				exit(EXIT_FAILURE);
 			else
-				printf("opt:%c\n", opt);
+				outputstd("opt:%c\n", opt);
 			return;
 
 		case '\0':
@@ -273,7 +273,7 @@ void parse_args(int argc, char *argv[])
 
 		case 'r':
 			if (do_exclude_syscall == TRUE) {
-				printf("-r needs to be before any -x options.\n");
+				outputerr("-r needs to be before any -x options.\n");
 				exit(EXIT_FAILURE);
 			}
 			random_selection = 1;
diff --git a/pids.c b/pids.c
index dd33d72..100bc69 100644
--- a/pids.c
+++ b/pids.c
@@ -54,7 +54,7 @@ void dump_pid_slots(void)
 		sptr += sprintf(sptr, "\n");
 	}
 	*sptr = '\0';
-	printf("%s", string);
+	outputerr("%s", string);
 }
 
 static pid_t pidmax;
@@ -95,7 +95,7 @@ void pids_init(void)
 #else
 		pidmax = 32768;
 #endif
-		printf("Couldn't read pid_max from proc\n");
+		outputerr("Couldn't read pid_max from proc\n");
 	}
 
 	printf("[init] Using pid_max = %d\n", pidmax);
diff --git a/seed.c b/seed.c
index 802d587..ac32f5b 100644
--- a/seed.c
+++ b/seed.c
@@ -19,7 +19,7 @@ unsigned int seed = 0;
 
 static void syslog_seed(int seedparam)
 {
-	fprintf(stderr, "Randomness reseeded to %u\n", seedparam);
+	outputerr("Randomness reseeded to %u\n", seedparam);
 	openlog("trinity", LOG_CONS|LOG_PERROR, LOG_USER);
 	syslog(LOG_CRIT, "Randomness reseeded to %u\n", seedparam);
 	closelog();
@@ -86,7 +86,7 @@ void reseed(void)
 	shm->reseed_counter = 0;
 
 	if (getpid() != mainpid) {
-		output(0, "Reseeding should only happen from parent!\n");
+		outputerr("Reseeding should only happen from parent!\n");
 		exit(EXIT_FAILURE);
 	}
 
diff --git a/sockets.c b/sockets.c
index c2037c9..32142ba 100644
--- a/sockets.c
+++ b/sockets.c
@@ -116,7 +116,7 @@ static void generate_sockets(void)
 
 	cachefile = creat(cachefilename, S_IWUSR|S_IRUSR);
 	if (cachefile < 0) {
-		printf("Couldn't open cachefile for writing! (%s)\n",
+		outputerr("Couldn't open cachefile for writing! (%s)\n",
 			strerror(errno));
 		exit(EXIT_FAILURE);
 	}
@@ -152,14 +152,14 @@ static void generate_sockets(void)
 				buffer[2] = st.protocol;
 				n = write(cachefile, &buffer, sizeof(int) * 3);
 				if (n == -1) {
-					printf("something went wrong writing the cachefile!\n");
+					outputerr("something went wrong writing the cachefile!\n");
 					exit(EXIT_FAILURE);
 				}
 
 				if (nr_to_create == 0)
 					goto done;
 			} else {
-				//printf("Couldn't open family:%d (%s)\n", st.family, get_proto_name(st.family));
+				//outputerr("Couldn't open family:%d (%s)\n", st.family, get_proto_name(st.family));
 			}
 skip:
 
diff --git a/syscalls/perf_event_open.c b/syscalls/perf_event_open.c
index dfcec77..468357a 100644
--- a/syscalls/perf_event_open.c
+++ b/syscalls/perf_event_open.c
@@ -15,6 +15,7 @@
 #include "compat.h"
 #include "maps.h"
 #include "shm.h"
+#include "log.h"
 
 #define SYSFS "/sys/bus/event_source/devices/"
 
@@ -97,7 +98,7 @@ static int parse_format(char *string, int *field_type, unsigned long long *mask)
 			if (string[i]=='-') break;
 			if (string[i]==',') break;
 			if ((string[i]<'0') || (string[i]>'9')) {
-				fprintf(stderr,"Unknown format char %c\n",string[i]);
+				outputerr("Unknown format char %c\n", string[i]);
 				return -1;
 			}
 			firstnum*=10;
@@ -119,7 +120,7 @@ static int parse_format(char *string, int *field_type, unsigned long long *mask)
 				if (string[i]=='-') break;
 				if (string[i]==',') break;
 				if ((string[i]<'0') || (string[i]>'9')) {
-					fprintf(stderr,"Unknown format char %c\n",string[i]);
+					outputerr("Unknown format char %c\n", string[i]);
 					return -1;
 				}
 				secondnum*=10;
@@ -238,7 +239,7 @@ static int parse_generic(int pmu, char *value,
 				if (value[ptr]==',') break;
 				if (! ( ((value[ptr]>='0') && (value[ptr]<='9'))
                    			|| ((value[ptr]>='a') && (value[ptr]<='f'))) ) {
-					fprintf(stderr,"Unexpected char %c\n",value[ptr]);
+					outputerr("Unexpected char %c\n", value[ptr]);
 				}
 				temp*=base;
 				if ((value[ptr]>='0') && (value[ptr]<='9')) {
diff --git a/tables.c b/tables.c
index 618d742..07d4346 100644
--- a/tables.c
+++ b/tables.c
@@ -245,7 +245,7 @@ static void check_syscall(struct syscall *entry)
 	if (entry->num_args > 0) {				\
 		if (entry->num_args > NUMARGS) {		\
 			if (entry->ARGNAME == NULL)  {		\
-				printf("arg %d of %s has no name\n", ARGNUM, entry->name);      \
+				outputerr("arg %d of %s has no name\n", ARGNUM, entry->name);      \
 				exit(EXIT_FAILURE);		\
 			}					\
 		}						\
@@ -265,7 +265,7 @@ static void check_syscall(struct syscall *entry)
 	if (entry->num_args > 0) {				\
 		if (entry->num_args > NUMARGS) {		\
 			if (entry->ARGTYPE == ARG_UNDEFINED) {	\
-				printf("%s has an undefined argument type for arg1 (%s)!\n", entry->name, entry->ARGNAME);	\
+				outputerr("%s has an undefined argument type for arg1 (%s)!\n", entry->name, entry->ARGNAME);	\
 			}					\
 		}						\
 	}							\
@@ -303,7 +303,7 @@ void mark_all_syscalls_active(void)
 {
 	unsigned int i;
 
-	printf("Marking all syscalls as enabled.\n");
+	outputstd("Marking all syscalls as enabled.\n");
 	if (biarch == TRUE) {
 		if (do_32_arch)
 			for_each_32bit_syscall(i) {
@@ -346,7 +346,7 @@ static void check_user_specified_arch(const char *arg, char **arg_name, bool *on
 				*only_64bit = FALSE;
 				*only_32bit = TRUE;
 			} else {
-				printf("Unknown bit width (%s). Choose 32, or 64.\n", arg);
+				outputerr("Unknown bit width (%s). Choose 32, or 64.\n", arg);
 				exit(EXIT_FAILURE);
 			}
 		}
@@ -405,12 +405,12 @@ static void toggle_syscall_biarch(const char *arg, bool state)
 
 
 	if ((!only_32bit) && (!only_64bit)) {
-		printf("No idea what architecture for syscall (%s) is.\n", arg);
+		outputerr("No idea what architecture for syscall (%s) is.\n", arg);
 		exit(EXIT_FAILURE);
 	}
 
 	if ((specific_syscall64 == -1) && (specific_syscall32 == -1)) {
-		printf("No idea what syscall (%s) is.\n", arg);
+		outputerr("No idea what syscall (%s) is.\n", arg);
 		exit(EXIT_FAILURE);
 	}
 
@@ -443,7 +443,7 @@ static void toggle_syscall_biarch(const char *arg, bool state)
 static void toggle_syscall_n(int calln, bool state, const char *arg, const char *arg_name)
 {
 	if (calln == -1) {
-		printf("No idea what syscall (%s) is.\n", arg);
+		outputerr("No idea what syscall (%s) is.\n", arg);
 		exit(EXIT_FAILURE);
 	}
 
@@ -517,9 +517,9 @@ void deactivate_disabled_syscalls(void)
 static void show_state(unsigned int state)
 {
 	if (state)
-		printf("Enabled");
+		outputstd("Enabled");
 	else
-		printf("Disabled");
+		outputstd("Disabled");
 }
 
 void dump_syscall_tables(void)
@@ -527,31 +527,31 @@ void dump_syscall_tables(void)
 	unsigned int i;
 
 	if (biarch == TRUE) {
-		printf("32-bit syscalls: %d\n", max_nr_32bit_syscalls);
-		printf("64-bit syscalls: %d\n", max_nr_64bit_syscalls);
+		outputstd("32-bit syscalls: %d\n", max_nr_32bit_syscalls);
+		outputstd("64-bit syscalls: %d\n", max_nr_64bit_syscalls);
 
 		for_each_32bit_syscall(i) {
-			printf("32-bit entrypoint %d %s : ", syscalls_32bit[i].entry->number, syscalls_32bit[i].entry->name);
+			outputstd("32-bit entrypoint %d %s : %s", syscalls_32bit[i].entry->number, syscalls_32bit[i].entry->name);
 			show_state(syscalls_32bit[i].entry->flags & ACTIVE);
 			if (syscalls_32bit[i].entry->flags & AVOID_SYSCALL)
-				printf(" AVOID");
-			printf("\n");
+				outputstd(" AVOID");
+			outputstd("\n");
 		}
 		for_each_64bit_syscall(i) {
-			printf("64-bit entrypoint %d %s : ", syscalls_64bit[i].entry->number, syscalls_64bit[i].entry->name);
+			outputstd("64-bit entrypoint %d %s : ", syscalls_64bit[i].entry->number, syscalls_64bit[i].entry->name);
 			show_state(syscalls_64bit[i].entry->flags & ACTIVE);
 			if (syscalls_64bit[i].entry->flags & AVOID_SYSCALL)
-				printf(" AVOID");
-			printf("\n");
+				outputstd(" AVOID");
+			outputstd("\n");
 		}
 	} else {
-		printf("syscalls: %d\n", max_nr_syscalls);
+		outputstd("syscalls: %d\n", max_nr_syscalls);
 		for_each_syscall(i) {
-			printf("%d %s : ", syscalls[i].entry->number, syscalls[i].entry->name);
+			outputstd("%d %s : ", syscalls[i].entry->number, syscalls[i].entry->name);
 			show_state(syscalls[i].entry->flags & ACTIVE);
 			if (syscalls[i].entry->flags & AVOID_SYSCALL)
-				printf(" AVOID");
-			printf("\n");
+				outputstd(" AVOID");
+			outputstd("\n");
 		}
 	}
 }
@@ -635,9 +635,9 @@ int setup_syscall_group(unsigned int group)
 		}
 
 		if (shm->nr_active_32bit_syscalls == 0) {
-			printf("No 32-bit syscalls in group\n");
+			outputstd("No 32-bit syscalls in group\n");
 		} else {
-			printf("Found %d 32-bit syscalls in group\n", shm->nr_active_32bit_syscalls);
+			outputstd("Found %d 32-bit syscalls in group\n", shm->nr_active_32bit_syscalls);
 		}
 
 		/* now the 64 bit table*/
@@ -647,10 +647,10 @@ int setup_syscall_group(unsigned int group)
 		}
 
 		if (shm->nr_active_64bit_syscalls == 0) {
-			printf("No 64-bit syscalls in group\n");
+			outputstd("No 64-bit syscalls in group\n");
 			return FALSE;
 		} else {
-			printf("Found %d 64-bit syscalls in group\n", shm->nr_active_64bit_syscalls);
+			outputstd("Found %d 64-bit syscalls in group\n", shm->nr_active_64bit_syscalls);
 		}
 
 	} else {
@@ -661,10 +661,10 @@ int setup_syscall_group(unsigned int group)
 		}
 
 		if (shm->nr_active_syscalls == 0) {
-			printf("No syscalls found in group\n");
+			outputstd("No syscalls found in group\n");
 			return FALSE;
 		} else {
-			printf("Found %d syscalls in group\n", shm->nr_active_syscalls);
+			outputstd("Found %d syscalls in group\n", shm->nr_active_syscalls);
 		}
 	}
 
@@ -690,7 +690,7 @@ const char * print_syscall_name(unsigned int callno, bool is32bit)
 	}
 
 	if (callno >= max) {
-		printf("Bogus syscall number in %s (%u)\n", __func__, callno);
+		outputstd("Bogus syscall number in %s (%u)\n", __func__, callno);
 		return "invalid-syscall";
 	}
 
@@ -818,23 +818,23 @@ void enable_random_syscalls(void)
 	unsigned int call, call32, call64;
 
 	if (random_selection_num == 0) {
-		printf("-r 0 syscalls ? what?\n");
+		outputerr("-r 0 syscalls ? what?\n");
 		exit(EXIT_FAILURE);
 	}
 
 	if (biarch == TRUE) {
 		if ((random_selection_num > max_nr_64bit_syscalls) && do_64_arch) {
-			printf("-r val %d out of range (1-%d)\n", random_selection_num, max_nr_64bit_syscalls);
+			outputerr("-r val %d out of range (1-%d)\n", random_selection_num, max_nr_64bit_syscalls);
 			exit(EXIT_FAILURE);
 		}
 	} else {
 		if (random_selection_num > max_nr_syscalls) {
-			printf("-r val %d out of range (1-%d)\n", random_selection_num, max_nr_syscalls);
+			outputerr("-r val %d out of range (1-%d)\n", random_selection_num, max_nr_syscalls);
 			exit(EXIT_FAILURE);
 		}
 	}
 
-	printf("Enabling %d random syscalls\n", random_selection_num);
+	outputerr("Enabling %d random syscalls\n", random_selection_num);
 
 	for (i = 0; i < random_selection_num; i++) {
 
diff --git a/trinity.c b/trinity.c
index 73627cf..8140da1 100644
--- a/trinity.c
+++ b/trinity.c
@@ -99,7 +99,7 @@ static void setup_shm_postargs(void)
 		shm->max_children = sysconf(_SC_NPROCESSORS_ONLN);
 
 	if (shm->max_children > MAX_NR_CHILDREN) {
-		printf("Increase MAX_NR_CHILDREN!\n");
+		outputerr("Increase MAX_NR_CHILDREN!\n");
 		exit(EXIT_FAILURE);
 	}
 }
@@ -145,8 +145,8 @@ static int munge_tables(void)
 		display_enabled_syscalls();
 
 	if (validate_syscall_tables() == FALSE) {
-		printf("No syscalls were enabled!\n");
-		printf("Use 32bit:%d 64bit:%d\n", use_32bit, use_64bit);
+		outputstd("No syscalls were enabled!\n");
+		outputstd("Use 32bit:%d 64bit:%d\n", use_32bit, use_64bit);
 		return FALSE;
 	}
 
@@ -230,17 +230,17 @@ int main(int argc, char* argv[])
 
 	if (getuid() == 0) {
 		if (dangerous == TRUE) {
-			printf("DANGER: RUNNING AS ROOT.\n");
-			printf("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
-			printf("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
-			printf("ctrl-c now unless you really know what you are doing.\n");
+			outputstd("DANGER: RUNNING AS ROOT.\n");
+			outputstd("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
+			outputstd("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
+			outputstd("ctrl-c now unless you really know what you are doing.\n");
 			for (i = 10; i > 0; i--) {
-				printf("Continuing in %d seconds.\r", i);
+				outputstd("Continuing in %d seconds.\r", i);
 				(void)fflush(stdout);
 				sleep(1);
 			}
 		} else {
-			printf("Don't run as root (or pass --dangerous if you know what you are doing).\n");
+			outputstd("Don't run as root (or pass --dangerous if you know what you are doing).\n");
 			exit(EXIT_FAILURE);
 		}
 	}
-- 
1.8.4

[PATCH 3/6] refactored output function

[Ildar Muslukhov]

Signed-off-by: Ildar Muslukhov <ildarm@google.com>

---
 log.c | 77 ++++++++++++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 48 insertions(+), 29 deletions(-)

diff --git a/log.c b/log.c
index 1298038..518dd81 100644
--- a/log.c
+++ b/log.c
@@ -10,7 +10,10 @@
 #include "pids.h"
 #include "log.h"
 
+#define BUFSIZE 1024
+
 FILE *mainlogfile;
+bool logfiles_opened = FALSE;
 
 void open_logfiles(void)
 {
@@ -36,6 +39,7 @@ void open_logfiles(void)
 		}
 	}
 	free(logfilename);
+	logfiles_opened = TRUE;
 }
 
 void close_logfiles(void)
@@ -124,6 +128,25 @@ void synclogs(void)
 	fsync(fileno(mainlogfile));
 }
 
+static FILE *robust_find_logfile_handle(void)
+{
+	unsigned int j;
+	FILE *handle = NULL;
+
+	if ((logging == TRUE) && (logfiles_opened)) {
+		handle = find_logfile_handle();
+		if (!handle) {
+			outputerr("## child logfile handle was null logging to main!\n");
+			(void)fflush(stdout);
+			for_each_pidslot(j)
+				shm->logfiles[j] = mainlogfile;
+			sleep(5);
+			handle = find_logfile_handle();
+		}
+	}
+	return handle;
+}
+
 /*
  * level defines whether it gets displayed to the screen with printf.
  * (it always logs).
@@ -139,8 +162,8 @@ void output(unsigned char level, const char *fmt, ...)
 	FILE *handle;
 	unsigned int len, i, j;
 	pid_t pid;
-	char outputbuf[1024];
-	char monobuf[1024];
+	char outputbuf[BUFSIZE];
+	char monobuf[BUFSIZE];
 	char *prefix = NULL;
 	char watchdog_prefix[]="[watchdog]";
 	char init_prefix[]="[init]";
@@ -151,6 +174,7 @@ void output(unsigned char level, const char *fmt, ...)
 	if (logging == FALSE && level >= quiet_level)
 		return;
 
+	/* prefix preparation */
 	pid = getpid();
 	if (pid == watchdog_pid)
 		prefix = watchdog_prefix;
@@ -167,6 +191,7 @@ void output(unsigned char level, const char *fmt, ...)
 		prefix = child_prefix;
 	}
 
+	/* formatting output */
 	va_start(args, fmt);
 	n = vsnprintf(outputbuf, sizeof(outputbuf), fmt, args);
 	va_end(args);
@@ -176,49 +201,43 @@ void output(unsigned char level, const char *fmt, ...)
 		exit(EXIT_FAILURE);
 	}
 
+	/* stdout output if needed */
 	if (quiet_level > level) {
 		printf("%s %s", prefix, outputbuf);
 		(void)fflush(stdout);
 	}
 
+	/* go on with file logs only if enabled */
 	if (logging == FALSE)
 		return;
 
-	handle = find_logfile_handle();
-	if (!handle) {
-		printf("## child logfile handle was null logging to main!\n");
-		(void)fflush(stdout);
-		for_each_pidslot(j)
-			shm->logfiles[j] = mainlogfile;
-		sleep(5);
+	handle = robust_find_logfile_handle();
+	if (!handle)
 		return;
-	}
 
 	/* If we've specified monochrome, we can just dump the buffer into
 	 * the logfile as is, because there shouldn't be any ANSI codes
 	 * in the buffer to be stripped out. */
-	if (monochrome == TRUE) {
-		fprintf(handle, "%s %s", prefix, outputbuf);
-		(void)fflush(handle);
-		return;
-	}
-
-	/* copy buffer, sans ANSI codes */
-	len = strlen(outputbuf);
-	for (i = 0, j = 0; i < len; i++) {
-		if (outputbuf[i] == '^[') {
-			if (outputbuf[i + 2] == '1')
-				i += 6;	// ANSI_COLOUR
-			else
-				i += 3;	// ANSI_RESET
-		} else {
-			monobuf[j] = outputbuf[i];
-			j++;
+	if (monochrome == FALSE) {
+		/* copy buffer, sans ANSI codes */
+		len = strlen(outputbuf);
+		for (i = 0, j = 0; (i < len) && (i + 2 < BUFSIZE) && (j < BUFSIZE); i++) {
+			if (outputbuf[i] == '^[') {
+				if (outputbuf[i + 2] == '1')
+					i += 6;	// ANSI_COLOUR
+				else
+					i += 3;	// ANSI_RESET
+			} else {
+				monobuf[j] = outputbuf[i];
+				j++;
+			}
 		}
+		monobuf[j] = '\0';
+		fprintf(handle, "%s %s", prefix, monobuf);
+	} else {
+		fprintf(handle, "%s %s", prefix, outputbuf);
 	}
-	monobuf[j] = '\0';
 
-	fprintf(handle, "%s %s", prefix, monobuf);
 	(void)fflush(handle);
 }
 
-- 
1.8.4

[PATCH 4/6] wired in output function instead of printf (and some missing outputstd)

[Ildar Muslukhov]

Signed-off-by: Ildar Muslukhov <ildarm@google.com>

---
 children/random-syscalls.c |  9 ++-------
 net/protocols.c            |  4 ++--
 pids.c                     |  2 +-
 seed.c                     |  7 +++++--
 sockets.c                  | 10 +++++-----
 tables.c                   | 34 +++++++++++++++++-----------------
 trinity.c                  |  8 ++++----
 watchdog.c                 |  8 ++++----
 8 files changed, 40 insertions(+), 42 deletions(-)

diff --git a/children/random-syscalls.c b/children/random-syscalls.c
index 8f8d770..553586d 100644
--- a/children/random-syscalls.c
+++ b/children/random-syscalls.c
@@ -76,7 +76,6 @@ extern int sigwas;
 
 int child_random_syscalls(int childno)
 {
-	pid_t pid = getpid();
 	int ret;
 	unsigned int syscallnr;
 
@@ -139,14 +138,10 @@ int child_random_syscalls(int childno)
 
 		if (syscalls_todo) {
 			if (shm->total_syscalls_done >= syscalls_todo) {
-				output(0, "[%d] shm->total_syscalls_done (%d) >= syscalls_todo (%d)\n",
-					pid, shm->total_syscalls_done,syscalls_todo);
+				output(0, "Reached maximum syscall count (todo = %d, done = %d), exiting...\n",
+					syscalls_todo, shm->total_syscalls_done);
 				shm->exit_reason = EXIT_REACHED_COUNT;
 			}
-
-			if (shm->total_syscalls_done == syscalls_todo)
-				printf("[%d] Reached maximum syscall count %ld\n",
-					pid, shm->total_syscalls_done);
 		}
 
 		ret = mkcall(childno);
diff --git a/net/protocols.c b/net/protocols.c
index 3cec507..891acfe 100644
--- a/net/protocols.c
+++ b/net/protocols.c
@@ -77,7 +77,7 @@ void find_specific_proto(const char *protoarg)
 		for (i = 0; i < ARRAY_SIZE(protocols); i++) {
 			if (strcmp(protoarg, protocols[i].name) == 0) {
 				specific_proto = protocols[i].proto;
-				printf("Proto %s = %d\n", protoarg, specific_proto);
+				output(2, "Proto %s = %d\n", protoarg, specific_proto);
 				break;
 			}
 		}
@@ -98,5 +98,5 @@ void find_specific_proto(const char *protoarg)
 		exit(EXIT_FAILURE);
 	}
 
-	printf("Using protocol %s (%u) for all sockets\n", protocols[i].name, protocols[i].proto);
+	output(2, "Using protocol %s (%u) for all sockets\n", protocols[i].name, protocols[i].proto);
 }
diff --git a/pids.c b/pids.c
index 100bc69..a2005c1 100644
--- a/pids.c
+++ b/pids.c
@@ -98,7 +98,7 @@ void pids_init(void)
 		outputerr("Couldn't read pid_max from proc\n");
 	}
 
-	printf("[init] Using pid_max = %d\n", pidmax);
+	output(0, "Using pid_max = %d\n", pidmax);
 }
 
 int pid_is_valid(pid_t pid)
diff --git a/seed.c b/seed.c
index ac32f5b..a9c6f6a 100644
--- a/seed.c
+++ b/seed.c
@@ -50,11 +50,11 @@ unsigned int new_seed(void)
 unsigned int init_seed(unsigned int seedparam)
 {
 	if (user_set_seed == TRUE)
-		printf("Using user passed random seed: %u\n", seedparam);
+		output(0, "Using user passed random seed: %u\n", seedparam);
 	else {
 		seedparam = new_seed();
 
-		printf("Initial random seed: %u\n", seedparam);
+		output(0, "Initial random seed: %u\n", seedparam);
 	}
 
 	if (do_syslog == TRUE)
@@ -69,6 +69,9 @@ unsigned int init_seed(unsigned int seedparam)
  */
 void set_seed(unsigned int pidslot)
 {
+	pid_t pid = getpid();
+	if ((pid != watchdog_pid) && (pid != initpid) && (pid != mainpid))
+		output(0, "Setting seed: %u\n", shm->seed + (pidslot + 1));
 	srand(shm->seed + (pidslot + 1));
 	shm->seeds[pidslot] = shm->seed;
 }
diff --git a/sockets.c b/sockets.c
index 32142ba..de43d4b 100644
--- a/sockets.c
+++ b/sockets.c
@@ -190,7 +190,7 @@ static void close_sockets(void)
 		fd = shm->socket_fds[i];
 		shm->socket_fds[i] = 0;
 		if (close(fd) != 0) {
-			printf("failed to close socket.(%s)\n", strerror(errno));
+			output(1, "failed to close socket.(%s)\n", strerror(errno));
 		}
 	}
 
@@ -211,7 +211,7 @@ void open_sockets(void)
 
 	cachefile = open(cachefilename, O_RDONLY);
 	if (cachefile < 0) {
-		printf("Couldn't find socket cachefile. Regenerating.\n");
+		output(1, "Couldn't find socket cachefile. Regenerating.\n");
 		generate_sockets();
 		return;
 	}
@@ -229,7 +229,7 @@ void open_sockets(void)
 
 		if (do_specific_proto == TRUE) {
 			if (domain != specific_proto) {
-				printf("ignoring socket cachefile due to specific protocol request, and stale data in cachefile.\n");
+				output(1, "ignoring socket cachefile due to specific protocol request, and stale data in cachefile.\n");
 regenerate:
 				unlock_cachefile(cachefile);	/* drop the reader lock. */
 				close(cachefile);
@@ -241,7 +241,7 @@ regenerate:
 
 		fd = open_socket(domain, type, protocol);
 		if (fd < 0) {
-			printf("Cachefile is stale. Need to regenerate.\n");
+			output(1, "Cachefile is stale. Need to regenerate.\n");
 			close_sockets();
 			goto regenerate;
 		}
@@ -254,7 +254,7 @@ regenerate:
 	}
 
 	if (nr_sockets < NR_SOCKET_FDS) {
-		printf("Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
+		output(1, "Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
 		goto regenerate;
 	}
 
diff --git a/tables.c b/tables.c
index 07d4346..fab6675 100644
--- a/tables.c
+++ b/tables.c
@@ -52,10 +52,10 @@ static void validate_specific_syscall(const struct syscalltable *table, int call
 		return;
 
 	if (table[call].entry->flags & AVOID_SYSCALL)
-		printf("%s is marked as AVOID. Skipping\n", table[call].entry->name);
+		output(0, "%s is marked as AVOID. Skipping\n", table[call].entry->name);
 
 	if (table[call].entry->flags & NI_SYSCALL)
-		printf("%s is NI_SYSCALL. Skipping\n", table[call].entry->name);
+		output(0, "%s is NI_SYSCALL. Skipping\n", table[call].entry->name);
 }
 
 int validate_specific_syscall_silent(const struct syscalltable *table, int call)
@@ -145,12 +145,12 @@ void deactivate_syscall(unsigned int calln)
 void count_syscalls_enabled(void)
 {
 	if (biarch == TRUE) {
-		printf("[init] 32-bit syscalls: %d enabled, %d disabled.  "
+		output(0, "32-bit syscalls: %d enabled, %d disabled.  "
 			"64-bit syscalls: %d enabled, %d disabled.\n",
 			shm->nr_active_32bit_syscalls, max_nr_32bit_syscalls - shm->nr_active_32bit_syscalls,
 			shm->nr_active_64bit_syscalls, max_nr_64bit_syscalls - shm->nr_active_64bit_syscalls);
 	} else {
-		printf("Enabled %d syscalls. Disabled %d syscalls.\n",
+		output(0, "Enabled %d syscalls. Disabled %d syscalls.\n",
 			shm->nr_active_syscalls, max_nr_syscalls - shm->nr_active_syscalls);
 	}
 }
@@ -380,7 +380,7 @@ static void toggle_syscall_biarch_n(int calln, const struct syscalltable *table,
 	}
 
 	if ((arch_bits != 0) && (calln != -1))
-		printf("Marking %d-bit syscall %s (%d) as to be %sabled.\n",
+		output(0, "Marking %d-bit syscall %s (%d) as to be %sabled.\n",
 			arch_bits, arg_name, calln,
 			state ? "en" : "dis");
 }
@@ -415,7 +415,7 @@ static void toggle_syscall_biarch(const char *arg, bool state)
 	}
 
 	if ((specific_syscall64 != -1) && (specific_syscall32 != -1)) {
-		printf("Marking syscall %s (64bit:%d 32bit:%d) as to be %sabled.\n",
+		output(0, "Marking syscall %s (64bit:%d 32bit:%d) as to be %sabled.\n",
 			arg_name, specific_syscall64, specific_syscall32,
 			state ? "en" : "dis");
 		clear_check_user_specified_arch(arg, &arg_name);
@@ -423,7 +423,7 @@ static void toggle_syscall_biarch(const char *arg, bool state)
 	}
 
 	if (specific_syscall64 != -1) {
-		printf("Marking 64-bit syscall %s (%d) as to be %sabled.\n",
+		output(0, "Marking 64-bit syscall %s (%d) as to be %sabled.\n",
 			arg, specific_syscall64,
 			state ? "en" : "dis");
 		clear_check_user_specified_arch(arg, &arg_name);
@@ -431,7 +431,7 @@ static void toggle_syscall_biarch(const char *arg, bool state)
 	}
 
 	if  (specific_syscall32 != -1) {
-		printf("Marking 32-bit syscall %s (%d) as to be %sabled.\n",
+		output(0, "Marking 32-bit syscall %s (%d) as to be %sabled.\n",
 			arg, specific_syscall32,
 			state ? "en" : "dis");
 		clear_check_user_specified_arch(arg, &arg_name);
@@ -456,7 +456,7 @@ static void toggle_syscall_n(int calln, bool state, const char *arg, const char
 		syscalls[calln].entry->flags |= TO_BE_DEACTIVATED;
 	}
 
-	printf("Marking syscall %s (%d) as to be %sabled.\n",
+	output(0, "Marking syscall %s (%d) as to be %sabled.\n",
 		arg_name, calln,
 		state ? "en" : "dis");
 }
@@ -482,14 +482,14 @@ void deactivate_disabled_syscalls(void)
 {
 	unsigned int i;
 
-	printf("Disabling syscalls marked as disabled by command line options\n");
+	output(0, "Disabling syscalls marked as disabled by command line options\n");
 
 	if (biarch == TRUE) {
 		for_each_64bit_syscall(i) {
 			if (syscalls_64bit[i].entry->flags & TO_BE_DEACTIVATED) {
 				syscalls_64bit[i].entry->flags &= ~(ACTIVE|TO_BE_DEACTIVATED);
 				deactivate_syscall64(i);
-				printf("Marked 64-bit syscall %s (%d) as deactivated.\n",
+				output(0, "Marked 64-bit syscall %s (%d) as deactivated.\n",
 					syscalls_64bit[i].entry->name, syscalls_64bit[i].entry->number);
 			}
 		}
@@ -497,7 +497,7 @@ void deactivate_disabled_syscalls(void)
 			if (syscalls_32bit[i].entry->flags & TO_BE_DEACTIVATED) {
 				syscalls_32bit[i].entry->flags &= ~(ACTIVE|TO_BE_DEACTIVATED);
 				deactivate_syscall32(i);
-				printf("Marked 32-bit syscall %s (%d) as deactivated.\n",
+				output(0, "Marked 32-bit syscall %s (%d) as deactivated.\n",
 					syscalls_32bit[i].entry->name, syscalls_32bit[i].entry->number);
 			}
 		}
@@ -507,7 +507,7 @@ void deactivate_disabled_syscalls(void)
 			if (syscalls[i].entry->flags & TO_BE_DEACTIVATED) {
 				syscalls[i].entry->flags &= ~(ACTIVE|TO_BE_DEACTIVATED);
 				deactivate_syscall(i);
-				printf("Marked syscall %s (%d) as deactivated.\n",
+				output(0, "Marked syscall %s (%d) as deactivated.\n",
 					syscalls[i].entry->name, syscalls[i].entry->number);
 			}
 		}
@@ -704,19 +704,19 @@ void display_enabled_syscalls(void)
 	if (biarch == TRUE) {
 		for_each_64bit_syscall(i) {
 			if (syscalls_64bit[i].entry->flags & ACTIVE)
-				printf("64-bit syscall %d:%s enabled.\n", i, syscalls_64bit[i].entry->name);
+				output(0, "64-bit syscall %d:%s enabled.\n", i, syscalls_64bit[i].entry->name);
 		}
 
 		for_each_32bit_syscall(i) {
 			if (syscalls_32bit[i].entry->flags & ACTIVE)
-				printf("32-bit syscall %d:%s enabled.\n", i, syscalls_32bit[i].entry->name);
+				output(0, "32-bit syscall %d:%s enabled.\n", i, syscalls_32bit[i].entry->name);
 		}
 
 	} else {
 		/* non-biarch */
 		for_each_syscall(i) {
 			if (syscalls[i].entry->flags & ACTIVE)
-				printf("syscall %d:%s enabled.\n", i, syscalls[i].entry->name);
+				output(0, "syscall %d:%s enabled.\n", i, syscalls[i].entry->name);
 		}
 	}
 }
@@ -766,7 +766,7 @@ void disable_non_net_syscalls(void)
 {
 	unsigned int i;
 
-	printf("Disabling non networking related syscalls\n");
+	output(0, "Disabling non networking related syscalls\n");
 
 	if (biarch == TRUE) {
 		for_each_64bit_syscall(i) {
diff --git a/trinity.c b/trinity.c
index 8140da1..63f205c 100644
--- a/trinity.c
+++ b/trinity.c
@@ -185,7 +185,7 @@ int main(int argc, char* argv[])
 	int childstatus;
 	unsigned int i;
 
-	printf("Trinity v" __stringify(VERSION) "  Dave Jones <davej@redhat.com>\n");
+	outputstd("Trinity v" __stringify(VERSION) "  Dave Jones <davej@redhat.com>\n");
 
 	progname = argv[0];
 
@@ -200,10 +200,10 @@ int main(int argc, char* argv[])
 		exit(EXIT_FAILURE);
 
 	parse_args(argc, argv);
-	printf("Done parsing arguments.\n");
+	outputstd("Done parsing arguments.\n");
 
 	if (kernel_taint_mask != (int)0xFFFFFFFF) {
-		printf("Custom kernel taint mask has been specified: 0x%08x (%d).\n", kernel_taint_mask, kernel_taint_mask);
+		outputstd("Custom kernel taint mask has been specified: 0x%08x (%d).\n", kernel_taint_mask, kernel_taint_mask);
 	}
 
 	setup_shm_postargs();
@@ -274,7 +274,7 @@ int main(int argc, char* argv[])
 	/* Shutting down. */
 	waitpid(watchdog_pid, &childstatus, 0);
 
-	printf("\nRan %ld syscalls. Successes: %ld  Failures: %ld\n",
+	output(0, "\nRan %ld syscalls. Successes: %ld  Failures: %ld\n",
 		shm->total_syscalls_done - 1, shm->successes, shm->failures);
 
 	ret = EXIT_SUCCESS;
diff --git a/watchdog.c b/watchdog.c
index 7f9999b..268c401 100644
--- a/watchdog.c
+++ b/watchdog.c
@@ -188,7 +188,7 @@ static void check_children(void)
 
 		/* if we wrapped, just reset it, we'll pick it up next time around. */
 		if (old > (now + 3)) {
-			printf("child %d wrapped! old=%ld now=%ld\n", i, old, now);
+			output(1, "child %d wrapped! old=%ld now=%ld\n", i, old, now);
 			shm->tv[i].tv_sec = now;
 			continue;
 		}
@@ -275,7 +275,7 @@ static void watchdog(void)
 	bool watchdog_exit = FALSE;
 	int ret = 0;
 
-	printf("[watchdog] Watchdog is alive. (pid:%d)\n", watchdog_pid);
+	output(0, "Watchdog is alive. (pid:%d)\n", watchdog_pid);
 
 	prctl(PR_SET_NAME, (unsigned long) &watchdogname);
 	(void)signal(SIGSEGV, SIG_DFL);
@@ -303,9 +303,9 @@ static void watchdog(void)
 			if (shm->total_syscalls_done % 1000 == 0)
 				synclogs();
 
-			if ((quiet_level > 1) && (shm->total_syscalls_done > 1)) {
+			if (shm->total_syscalls_done > 1) {
 				if (shm->total_syscalls_done - lastcount > 10000) {
-					printf("[watchdog] %ld iterations. [F:%ld S:%ld]\n",
+					output(0, "%ld iterations. [F:%ld S:%ld]\n",
 						shm->total_syscalls_done, shm->failures, shm->successes);
 					lastcount = shm->total_syscalls_done;
 				}
-- 
1.8.4

[PATCH 5/6] added bufferless logging functions for syscall pamaters

[Ildar Muslukhov]

Signed-off-by: Ildar Muslukhov <ildarm@google.com>

---
 include/log.h |   9 ++++++
 log.c         | 101 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 110 insertions(+)

diff --git a/include/log.h b/include/log.h
index 7041eda..76b825e 100644
--- a/include/log.h
+++ b/include/log.h
@@ -1,6 +1,8 @@
 #ifndef _LOG_H
 #define _LOG_H 1
 
+#include "types.h"
+
 #define ANSI_RED	"^[[1;31m"
 #define ANSI_GREEN	"^[[1;32m"
 #define ANSI_YELLOW	"^[[1;33m"
@@ -21,12 +23,19 @@
 
 #define CRESETPTR if (monochrome == FALSE)	*sptr += sprintf(*sptr, "%s", ANSI_RESET);
 
+#define REDFD if (mono == FALSE)	fprintf(fd, "%s", ANSI_RED);
+#define GREENFD if (mono == FALSE)	fprintf(fd, "%s", ANSI_GREEN);
+#define CRESETFD if (mono == FALSE)	fprintf(fd, "%s", ANSI_RESET);
+
 #define MAX_LOGLEVEL 3
 unsigned int highest_logfile(void);
 void synclogs(void);
 void output(unsigned char level, const char *fmt, ...);
 void outputerr(const char *fmt, ...);
 void outputstd(const char *fmt, ...);
+void output_syscall_prefix(const unsigned int childno, const unsigned int syscallno);
+void output_syscall_postfix(unsigned long ret, int errno_saved, bool err);
+
 void open_logfiles(void);
 void close_logfiles(void);
 
diff --git a/log.c b/log.c
index 518dd81..2a9c140 100644
--- a/log.c
+++ b/log.c
@@ -9,6 +9,9 @@
 #include "shm.h"
 #include "pids.h"
 #include "log.h"
+#include "arch.h" //PAGE_MASK
+#include "maps.h" //pages
+#include "syscall.h" //syscalls
 
 #define BUFSIZE 1024
 
@@ -128,6 +131,10 @@ void synclogs(void)
 	fsync(fileno(mainlogfile));
 }
 
+static void output_arg(unsigned int call, unsigned int argnum, const char *name, unsigned long oldreg, unsigned long reg, int type, FILE *fd, bool mono)
+{
+}
+
 static FILE *robust_find_logfile_handle(void)
 {
 	unsigned int j;
@@ -262,3 +269,97 @@ void outputstd(const char *fmt, ...)
 	vfprintf(stdout, fmt, args);
 	va_end(args);
 }
+
+static void output_syscall_prefix_to_fd(const unsigned int childno, const pid_t pid, const unsigned int syscallno, FILE *fd, bool mono)
+{
+	fprintf(fd, "[child%d:%d] [%ld] %s", childno, pid, shm->child_syscall_count[childno],
+			(shm->do32bit[childno] == TRUE) ? "[32BIT] " : "");
+
+	if (syscallno > max_nr_syscalls)
+		fprintf(fd, "%u", syscallno);
+	else
+		fprintf(fd, "%s", syscalls[syscallno].entry->name);
+
+	CRESETFD
+	fprintf(fd, "(");
+	output_arg(syscallno, 1, syscalls[syscallno].entry->arg1name, shm->previous_a1[childno], shm->a1[childno],
+			syscalls[syscallno].entry->arg1type, fd, mono);
+	output_arg(syscallno, 2, syscalls[syscallno].entry->arg2name, shm->previous_a2[childno], shm->a2[childno],
+			syscalls[syscallno].entry->arg2type, fd, mono);
+	output_arg(syscallno, 3, syscalls[syscallno].entry->arg3name, shm->previous_a3[childno], shm->a3[childno],
+			syscalls[syscallno].entry->arg3type, fd, mono);
+	output_arg(syscallno, 4, syscalls[syscallno].entry->arg4name, shm->previous_a4[childno], shm->a4[childno],
+			syscalls[syscallno].entry->arg4type, fd, mono);
+	output_arg(syscallno, 5, syscalls[syscallno].entry->arg5name, shm->previous_a5[childno], shm->a5[childno],
+			syscalls[syscallno].entry->arg5type, fd, mono);
+	output_arg(syscallno, 6, syscalls[syscallno].entry->arg6name, shm->previous_a6[childno], shm->a6[childno],
+			syscalls[syscallno].entry->arg6type, fd, mono);
+	CRESETFD
+	fprintf(fd, ") ");
+}
+
+/* This function is always called from a fuzzing child. */
+void output_syscall_prefix(const unsigned int childno, const unsigned int syscallno)
+{
+	FILE *log_handle;
+	pid_t pid;
+
+	/* Exit if should not continue at all. */
+	if (logging == FALSE && quiet_level < MAX_LOGLEVEL)
+		return;
+	pid = getpid();
+
+	/* Find the log file handle */
+	log_handle = robust_find_logfile_handle();
+
+	/* do not output any ascii control symbols to files */
+	if ((logging == TRUE) && (log_handle != NULL))
+		output_syscall_prefix_to_fd(childno, pid, syscallno, log_handle, TRUE);
+
+	/* Output to stdout only if -q param is not specified */
+	if (quiet_level == MAX_LOGLEVEL)
+		output_syscall_prefix_to_fd(childno, pid, syscallno, stdout, monochrome);
+}
+
+static void output_syscall_postfix_err(unsigned long ret, int errno_saved, FILE *fd, bool mono)
+{
+	REDFD
+	fprintf(fd, "= %ld (%s)", ret, strerror(errno_saved));
+	CRESETFD
+	fprintf(fd, "\n");
+}
+
+static void output_syscall_postfix_success(unsigned long ret, FILE *fd, bool mono)
+{
+	GREENFD
+	if ((unsigned long)ret > 10000)
+		fprintf(fd, "= 0x%lx", ret);
+	else
+		fprintf(fd, "= %ld", ret);
+	CRESETFD
+	fprintf(fd, "\n");
+}
+
+void output_syscall_postfix(unsigned long ret, int errno_saved, bool err)
+{
+	FILE *log_handle;
+
+	/* Exit if should not continue at all. */
+	if (logging == FALSE && quiet_level < MAX_LOGLEVEL)
+		return;
+
+	/* Find the log file handle */
+	log_handle = robust_find_logfile_handle();
+
+	if (err) {
+		if ((logging == TRUE) && (log_handle != NULL))
+			output_syscall_postfix_err(ret, errno_saved, log_handle, TRUE);
+		if (quiet_level == MAX_LOGLEVEL)
+			output_syscall_postfix_err(ret, errno_saved, stdout, monochrome);
+	} else {
+		if ((logging == TRUE) && (log_handle != NULL))
+			output_syscall_postfix_success(ret, log_handle, TRUE);
+		if (quiet_level == MAX_LOGLEVEL)
+			output_syscall_postfix_success(ret, stdout, monochrome);
+	}
+}
\ No newline at end of file
-- 
1.8.4

[PATCH 6/6] wired syscall parameters logging function into syscall (this should fix stack smash bug detected)

[Ildar Muslukhov]

Signed-off-by: Ildar Muslukhov <ildarm@google.com>

---
 include/log.h |   3 --
 log.c         |  63 +++++++++++++++++++++++++-
 syscall.c     | 139 +++++-----------------------------------------------------
 3 files changed, 72 insertions(+), 133 deletions(-)

diff --git a/include/log.h b/include/log.h
index 76b825e..bc870ab 100644
--- a/include/log.h
+++ b/include/log.h
@@ -21,8 +21,6 @@
 #define WHITE if (monochrome == FALSE)	sptr += sprintf(sptr, "%s", ANSI_WHITE);
 #define CRESET if (monochrome == FALSE)	sptr += sprintf(sptr, "%s", ANSI_RESET);
 
-#define CRESETPTR if (monochrome == FALSE)	*sptr += sprintf(*sptr, "%s", ANSI_RESET);
-
 #define REDFD if (mono == FALSE)	fprintf(fd, "%s", ANSI_RED);
 #define GREENFD if (mono == FALSE)	fprintf(fd, "%s", ANSI_GREEN);
 #define CRESETFD if (mono == FALSE)	fprintf(fd, "%s", ANSI_RESET);
@@ -48,7 +46,6 @@ void close_logfiles(void);
 #define BUGTXT ANSI_RED "BUG!: " ANSI_RESET GIT_VERSION
 #endif
 
-
 #define BUG(bugtxt)	{ printf("%s:%s:%d %s", __FILE__, __func__, __LINE__, bugtxt); while(1); }
 
 #endif	/* _LOG_H */
diff --git a/log.c b/log.c
index 2a9c140..6340d59 100644
--- a/log.c
+++ b/log.c
@@ -133,6 +133,68 @@ void synclogs(void)
 
 static void output_arg(unsigned int call, unsigned int argnum, const char *name, unsigned long oldreg, unsigned long reg, int type, FILE *fd, bool mono)
 {
+	if (syscalls[call].entry->num_args >= argnum) {
+		if (!name)
+			return;
+
+		if (argnum != 1) {
+			CRESETFD
+			fprintf(fd, ", ");
+		}
+		if (name)
+			fprintf(fd, "%s=", name);
+
+		if (oldreg == reg) {
+			CRESETFD
+		} else {
+			if (mono == FALSE)
+				fprintf(fd, "%s", ANSI_CYAN);
+		}
+
+		switch (type) {
+		case ARG_PATHNAME:
+			fprintf(fd, "\"%s\"", (char *) reg);
+			break;
+		case ARG_PID:
+		case ARG_FD:
+			CRESETFD
+			fprintf(fd, "%ld", reg);
+			break;
+		case ARG_MODE_T:
+			CRESETFD
+			fprintf(fd, "%o", (mode_t) reg);
+			break;
+		case ARG_UNDEFINED:
+		case ARG_LEN:
+		case ARG_ADDRESS:
+		case ARG_NON_NULL_ADDRESS:
+		case ARG_RANGE:
+		case ARG_OP:
+		case ARG_LIST:
+		case ARG_RANDPAGE:
+		case ARG_CPU:
+		case ARG_RANDOM_LONG:
+		case ARG_IOVEC:
+		case ARG_IOVECLEN:
+		case ARG_SOCKADDR:
+		case ARG_SOCKADDRLEN:
+		default:
+			if (reg > 8 * 1024)
+				fprintf(fd, "0x%lx", reg);
+			else
+				fprintf(fd, "%ld", reg);
+			CRESETFD
+			break;
+		}
+		if (reg == (((unsigned long)page_zeros) & PAGE_MASK))
+			fprintf(fd, "[page_zeros]");
+		if (reg == (((unsigned long)page_rand) & PAGE_MASK))
+			fprintf(fd, "[page_rand]");
+		if (reg == (((unsigned long)page_0xff) & PAGE_MASK))
+			fprintf(fd, "[page_0xff]");
+		if (reg == (((unsigned long)page_allocs) & PAGE_MASK))
+			fprintf(fd, "[page_allocs]");
+	}
 }
 
 static FILE *robust_find_logfile_handle(void)
@@ -202,7 +264,6 @@ void output(unsigned char level, const char *fmt, ...)
 	va_start(args, fmt);
 	n = vsnprintf(outputbuf, sizeof(outputbuf), fmt, args);
 	va_end(args);
-
 	if (n < 0) {
 		outputerr("## Something went wrong in output() [%d]\n", n);
 		exit(EXIT_FAILURE);
diff --git a/syscall.c b/syscall.c
index 80f5a34..cb2defd 100644
--- a/syscall.c
+++ b/syscall.c
@@ -148,138 +148,35 @@ static unsigned long do_syscall(int childno, int *errno_saved)
 	return ret;
 }
 
-static void color_arg(unsigned int call, unsigned int argnum, const char *name, unsigned long oldreg, unsigned long reg, int type, char **sptr)
-{
-	if (syscalls[call].entry->num_args >= argnum) {
-		if (!name)
-			return;
-
-		if (argnum != 1) {
-			CRESETPTR
-			*sptr += sprintf(*sptr, ", ");
-		}
-		if (name)
-			*sptr += sprintf(*sptr, "%s=", name);
-
-		if (oldreg == reg) {
-			CRESETPTR
-		} else {
-			*sptr += sprintf(*sptr, "%s", ANSI_CYAN);
-		}
-
-		switch (type) {
-		case ARG_PATHNAME:
-			*sptr += sprintf(*sptr, "\"%s\"", (char *) reg);
-			break;
-		case ARG_PID:
-		case ARG_FD:
-			CRESETPTR
-			*sptr += sprintf(*sptr, "%ld", reg);
-			break;
-		case ARG_MODE_T:
-			CRESETPTR
-			*sptr += sprintf(*sptr, "%o", (mode_t) reg);
-			break;
-		case ARG_UNDEFINED:
-		case ARG_LEN:
-		case ARG_ADDRESS:
-		case ARG_NON_NULL_ADDRESS:
-		case ARG_RANGE:
-		case ARG_OP:
-		case ARG_LIST:
-		case ARG_RANDPAGE:
-		case ARG_CPU:
-		case ARG_RANDOM_LONG:
-		case ARG_IOVEC:
-		case ARG_IOVECLEN:
-		case ARG_SOCKADDR:
-		case ARG_SOCKADDRLEN:
-		default:
-			if (reg > 8 * 1024)
-				*sptr += sprintf(*sptr, "0x%lx", reg);
-			else
-				*sptr += sprintf(*sptr, "%ld", reg);
-			CRESETPTR
-			break;
-		}
-		if (reg == (((unsigned long)page_zeros) & PAGE_MASK))
-			*sptr += sprintf(*sptr, "[page_zeros]");
-		if (reg == (((unsigned long)page_rand) & PAGE_MASK))
-			*sptr += sprintf(*sptr, "[page_rand]");
-		if (reg == (((unsigned long)page_0xff) & PAGE_MASK))
-			*sptr += sprintf(*sptr, "[page_0xff]");
-		if (reg == (((unsigned long)page_allocs) & PAGE_MASK))
-			*sptr += sprintf(*sptr, "[page_allocs]");
-	}
-}
-
 /*
  * Generate arguments, print them out, then call the syscall.
  */
 long mkcall(int childno)
 {
-	unsigned long olda1, olda2, olda3, olda4, olda5, olda6;
 	unsigned int call = shm->syscallno[childno];
 	unsigned long ret = 0;
 	int errno_saved;
-	char string[512], *sptr;
 	uid_t olduid = getuid();
 
 	shm->regenerate++;
 
-	sptr = string;
-
-	sptr += sprintf(sptr, "[%ld] ", shm->child_syscall_count[childno]);
-	if (shm->do32bit[childno] == TRUE)
-		sptr += sprintf(sptr, "[32BIT] ");
-
-	olda1 = shm->a1[childno] = (unsigned long)rand64();
-	olda2 = shm->a2[childno] = (unsigned long)rand64();
-	olda3 = shm->a3[childno] = (unsigned long)rand64();
-	olda4 = shm->a4[childno] = (unsigned long)rand64();
-	olda5 = shm->a5[childno] = (unsigned long)rand64();
-	olda6 = shm->a6[childno] = (unsigned long)rand64();
-
-	if (call > max_nr_syscalls)
-		sptr += sprintf(sptr, "%u", call);
-	else
-		sptr += sprintf(sptr, "%s", syscalls[call].entry->name);
+	shm->a1[childno] = (unsigned long)rand64();
+	shm->a2[childno] = (unsigned long)rand64();
+	shm->a3[childno] = (unsigned long)rand64();
+	shm->a4[childno] = (unsigned long)rand64();
+	shm->a5[childno] = (unsigned long)rand64();
+	shm->a6[childno] = (unsigned long)rand64();
 
 	generic_sanitise(childno);
 	if (syscalls[call].entry->sanitise)
 		syscalls[call].entry->sanitise(childno);
 
-	/* micro-optimization. If we're not logging, and we're quiet, then
-	 * we can skip right over all of this. */
-	if ((logging == FALSE) && (quiet_level < MAX_LOGLEVEL))
-		goto skip_args;
-
-	CRESET
-	sptr += sprintf(sptr, "(");
-	color_arg(call, 1, syscalls[call].entry->arg1name, olda1, shm->a1[childno],
-			syscalls[call].entry->arg1type, &sptr);
-	color_arg(call, 2, syscalls[call].entry->arg2name, olda2, shm->a2[childno],
-			syscalls[call].entry->arg2type, &sptr);
-	color_arg(call, 3, syscalls[call].entry->arg3name, olda3, shm->a3[childno],
-			syscalls[call].entry->arg3type, &sptr);
-	color_arg(call, 4, syscalls[call].entry->arg4name, olda4, shm->a4[childno],
-			syscalls[call].entry->arg4type, &sptr);
-	color_arg(call, 5, syscalls[call].entry->arg5name, olda5, shm->a5[childno],
-			syscalls[call].entry->arg5type, &sptr);
-	color_arg(call, 6, syscalls[call].entry->arg6name, olda6, shm->a6[childno],
-			syscalls[call].entry->arg6type, &sptr);
-	CRESET
-	sptr += sprintf(sptr, ") ");
-	*sptr = '\0';
-
-	output(2, "%s", string);
+	output_syscall_prefix(childno, call);
 
 	/* If we're going to pause, might as well sync pre-syscall */
 	if (dopause == TRUE)
 		synclogs();
 
-skip_args:
-
 	if (((unsigned long)shm->a1 == (unsigned long) shm) ||
 	    ((unsigned long)shm->a2 == (unsigned long) shm) ||
 	    ((unsigned long)shm->a3 == (unsigned long) shm) ||
@@ -289,7 +186,6 @@ skip_args:
 		BUG("Address of shm ended up in a register!\n");
 	}
 
-
 	/* Some architectures (IA64/MIPS) start their Linux syscalls
 	 * At non-zero, and have other ABIs below.
 	 */
@@ -297,27 +193,12 @@ skip_args:
 
 	ret = do_syscall(childno, &errno_saved);
 
-	sptr = string;
-
-	if (IS_ERR(ret)) {
-		RED
-		sptr += sprintf(sptr, "= %ld (%s)", ret, strerror(errno_saved));
-		CRESET
+	if (IS_ERR(ret))
 		shm->failures++;
-	} else {
-		GREEN
-		if ((unsigned long)ret > 10000)
-			sptr += sprintf(sptr, "= 0x%lx", ret);
-		else
-			sptr += sprintf(sptr, "= %ld", ret);
-		CRESET
+	else
 		shm->successes++;
-	}
-
-	*sptr = '\0';
-
-	output(2, "%s\n", string);
 
+	output_syscall_postfix(ret, errno_saved, IS_ERR(ret));
 	if (dopause == TRUE)
 		sleep(1);
 
-- 
1.8.4

Re: [PATCH 4/6] wired in output function instead of printf (and some missing outputstd)

[Dave Jones]

On Tue, Oct 08, 2013 at 02:26:53PM -0700, Ildar Muslukhov wrote:
 
 
 >  void set_seed(unsigned int pidslot)
 >  {
 > +	pid_t pid = getpid();
 > +	if ((pid != watchdog_pid) && (pid != initpid) && (pid != mainpid))

As a follow-on patch, I suggest splitting this out into an is_child_pid() helper.

	Dave

Re: [PATCH 5/6] added bufferless logging functions for syscall pamaters

[Dave Jones]

On Tue, Oct 08, 2013 at 02:26:54PM -0700, Ildar Muslukhov wrote:

 > +static void output_arg(unsigned int call, unsigned int argnum, const char *name, unsigned long oldreg, unsigned long reg, int type, FILE *fd, bool mono)
 > +{
 > +}
 > +

uh, what ?
 
 > +
 > +static void output_syscall_prefix_to_fd(const unsigned int childno, const pid_t pid, const unsigned int syscallno, FILE *fd, bool mono)
 > +{
 > +	fprintf(fd, "[child%d:%d] [%ld] %s", childno, pid, shm->child_syscall_count[childno],
 > +			(shm->do32bit[childno] == TRUE) ? "[32BIT] " : "");
 > +
 > +	if (syscallno > max_nr_syscalls)
 > +		fprintf(fd, "%u", syscallno);
 > +	else
 > +		fprintf(fd, "%s", syscalls[syscallno].entry->name);
 > +
 > +	CRESETFD
 > +	fprintf(fd, "(");
 > +	output_arg(syscallno, 1, syscalls[syscallno].entry->arg1name, shm->previous_a1[childno], shm->a1[childno],
 > +			syscalls[syscallno].entry->arg1type, fd, mono);
 > +	output_arg(syscallno, 2, syscalls[syscallno].entry->arg2name, shm->previous_a2[childno], shm->a2[childno],
 > +			syscalls[syscallno].entry->arg2type, fd, mono);
 > +	output_arg(syscallno, 3, syscalls[syscallno].entry->arg3name, shm->previous_a3[childno], shm->a3[childno],
 > +			syscalls[syscallno].entry->arg3type, fd, mono);
 > +	output_arg(syscallno, 4, syscalls[syscallno].entry->arg4name, shm->previous_a4[childno], shm->a4[childno],
 > +			syscalls[syscallno].entry->arg4type, fd, mono);
 > +	output_arg(syscallno, 5, syscalls[syscallno].entry->arg5name, shm->previous_a5[childno], shm->a5[childno],
 > +			syscalls[syscallno].entry->arg5type, fd, mono);
 > +	output_arg(syscallno, 6, syscalls[syscallno].entry->arg6name, shm->previous_a6[childno], shm->a6[childno],
 > +			syscalls[syscallno].entry->arg6type, fd, mono);
 > +	CRESETFD
 > +	fprintf(fd, ") ");
 > +}


	Dave

Re: [PATCH 6/6] wired syscall parameters logging function into syscall (this should fix stack smash bug detected)

[Dave Jones]

On Tue, Oct 08, 2013 at 02:26:55PM -0700, Ildar Muslukhov wrote:
 
 > diff --git a/log.c b/log.c
 > index 2a9c140..6340d59 100644
 > --- a/log.c
 > +++ b/log.c
 > @@ -133,6 +133,68 @@ void synclogs(void)
 >  
 >  static void output_arg(unsigned int call, unsigned int argnum, const char *name, unsigned long oldreg, unsigned long reg, int type, FILE *fd, bool mono)
 >  {
 > +	if (syscalls[call].entry->num_args >= argnum) {
 > +		if (!name)
 > +			return;
 > +
 > +		if (argnum != 1) {
 > +			CRESETFD
 
oh, you add it in the next patch.. this won't work. Patch series need
to be functional at every step, or the ability to use git-bisect breaks.

	Dave

Re: [PATCH 4/6] wired in output function instead of printf (and some missing outputstd)

[Dave Jones]

On Wed, Oct 09, 2013 at 12:23:36PM -0400, Dave Jones wrote:
 > On Tue, Oct 08, 2013 at 02:26:53PM -0700, Ildar Muslukhov wrote:
 >  
 >  
 >  >  void set_seed(unsigned int pidslot)
 >  >  {
 >  > +	pid_t pid = getpid();
 >  > +	if ((pid != watchdog_pid) && (pid != initpid) && (pid != mainpid))
 > 
 > As a follow-on patch, I suggest splitting this out into an is_child_pid() helper.

on second thought, the printing of the seed from the child is a) pointless because
we can infer it from the main seed, and b) really noisy (especially when you run a lot of children).

let's drop this chunk

	Dave

Re: [PATCH 3/6] refactored output function

[Dave Jones]

Since applying this patch, coverity is picking up an out of bounds write.
It looks like it can't happen, but I'm wondering why this code was
done this way..

hand-editted diff for clarity:

 >  	/* copy buffer, sans ANSI codes */
 >  	len = strlen(outputbuf);
 > -	for (i = 0, j = 0; i < len; i++) {
 > +	for (i = 0, j = 0; (i < len) && (i + 2 < BUFSIZE) && (j < BUFSIZE); i++) {
 >  		if (outputbuf[i] == '^[') {
 >  			if (outputbuf[i + 2] == '1')
 >  				i += 6;	// ANSI_COLOUR
 >  			else
 >  				i += 3;	// ANSI_RESET
 >  		} else {
 >  			monobuf[j] = outputbuf[i];
 >  			j++;
 >    		}
 >  	}
 >  	monobuf[j] = '\0';

What's the intent behind this ?
It seems redundant, as everything seems to work fine without this change.

	Dave

Re: [PATCH 3/6] refactored output function

[Ildar Muslukhov]

Sorry, just noticed this one.

I added it just for robustness in future, as the buffered output was
also working till the point when it got overflown. This way buffer
won't be overflown.

-Ildar

On Thu, Oct 10, 2013 at 11:20 AM, Dave Jones <davej@redhat.com> wrote:
> Since applying this patch, coverity is picking up an out of bounds write.
> It looks like it can't happen, but I'm wondering why this code was
> done this way..
>
> hand-editted diff for clarity:
>
>  >      /* copy buffer, sans ANSI codes */
>  >      len = strlen(outputbuf);
>  > -    for (i = 0, j = 0; i < len; i++) {
>  > +    for (i = 0, j = 0; (i < len) && (i + 2 < BUFSIZE) && (j < BUFSIZE); i++) {
>  >              if (outputbuf[i] == ' ') {
>  >                      if (outputbuf[i + 2] == '1')
>  >                              i += 6; // ANSI_COLOUR
>  >                      else
>  >                              i += 3; // ANSI_RESET
>  >              } else {
>  >                      monobuf[j] = outputbuf[i];
>  >                      j++;
>  >              }
>  >      }
>  >      monobuf[j] = '\0';
>
> What's the intent behind this ?
> It seems redundant, as everything seems to work fine without this change.
>
>         Dave
>