Convert return values to bool in fpm_trace.c files

Girgias · Girgias · commit 08189b1773e6 · 2022-11-09T15:39:29.000Z
The return value was always either 0 or -1
diff --git a/sapi/fpm/fpm/fpm_php_trace.c b/sapi/fpm/fpm/fpm_php_trace.c
@@ -52,19 +52,19 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 
 	fprintf(slowlog, "\n%s [pool %s] pid %d\n", buf, child->wp->config->name, (int) pid);
 
-	if (0 > fpm_trace_get_long((long) &SG(request_info).path_translated, &l)) {
+	if (!fpm_trace_get_long((long) &SG(request_info).path_translated, &l)) {
 		return false;
 	}
 
 	path_translated = l;
 
-	if (0 > fpm_trace_get_strz(buf, buf_size, path_translated)) {
+	if (!fpm_trace_get_strz(buf, buf_size, path_translated)) {
 		return false;
 	}
 
 	fprintf(slowlog, "script_filename = %s\n", buf);
 
-	if (0 > fpm_trace_get_long((long) &EG(current_execute_data), &l)) {
+	if (!fpm_trace_get_long((long) &EG(current_execute_data), &l)) {
 		return false;
 	}
 
@@ -77,22 +77,22 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 		long prev;
 		uint32_t lineno = 0;
 
-		if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, func), &l)) {
+		if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, func), &l)) {
 			return false;
 		}
 
 		function = l;
 
 		if (valid_ptr(function)) {
-			if (0 > fpm_trace_get_long(function + offsetof(zend_function, common.function_name), &l)) {
+			if (!fpm_trace_get_long(function + offsetof(zend_function, common.function_name), &l)) {
 				return false;
 			}
 
 			function_name = l;
 
 			if (function_name == 0) {
 				uint32_t *call_info = (uint32_t *)&l;
-				if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, This.u1.type_info), &l)) {
+				if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, This.u1.type_info), &l)) {
 					return false;
 				}
 
@@ -104,7 +104,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 					ZEND_UNREACHABLE();
 				}
 			} else {
-				if (0 > fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {
+				if (!fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {
 					return false;
 				}
 
@@ -119,7 +119,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 
 		*buf = '\0';
 
-		if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, prev_execute_data), &l)) {
+		if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, prev_execute_data), &l)) {
 			return false;
 		}
 
@@ -128,7 +128,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 		while (prev) {
 			zend_uchar *type;
 
-			if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, func), &l)) {
+			if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, func), &l)) {
 				return false;
 			}
 
@@ -139,30 +139,30 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 			}
 
 			type = (zend_uchar *)&l;
-			if (0 > fpm_trace_get_long(function + offsetof(zend_function, type), &l)) {
+			if (!fpm_trace_get_long(function + offsetof(zend_function, type), &l)) {
 				return false;
 			}
 
 			if (ZEND_USER_CODE(*type)) {
-				if (0 > fpm_trace_get_long(function + offsetof(zend_op_array, filename), &l)) {
+				if (!fpm_trace_get_long(function + offsetof(zend_op_array, filename), &l)) {
 					return false;
 				}
 
 				file_name = l;
 
-				if (0 > fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {
+				if (!fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {
 					return false;
 				}
 
-				if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, opline), &l)) {
+				if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, opline), &l)) {
 					return false;
 				}
 
 				if (valid_ptr(l)) {
 					long opline = l;
 					uint32_t *lu = (uint32_t *) &l;
 
-					if (0 > fpm_trace_get_long(opline + offsetof(struct _zend_op, lineno), &l)) {
+					if (!fpm_trace_get_long(opline + offsetof(struct _zend_op, lineno), &l)) {
 						return false;
 					}
 
@@ -171,7 +171,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{
 				break;
 			}
 
-			if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, prev_execute_data), &l)) {
+			if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, prev_execute_data), &l)) {
 				return false;
 			}
 
@@ -203,15 +203,15 @@ void fpm_php_trace(struct fpm_child_s *child) /* {{{ */
 		goto done0;
 	}
 
-	if (0 > fpm_trace_ready(child->pid)) {
+	if (!fpm_trace_ready(child->pid)) {
 		goto done1;
 	}
 
 	if (!fpm_php_trace_dump(child, slowlog)) {
 		fprintf(slowlog, "+++ dump failed\n");
 	}
 
-	if (0 > fpm_trace_close(child->pid)) {
+	if (!fpm_trace_close(child->pid)) {
 		goto done1;
 	}
 
diff --git a/sapi/fpm/fpm/fpm_trace.c b/sapi/fpm/fpm/fpm_trace.c
@@ -6,7 +6,7 @@
 
 #include "fpm_trace.h"
 
-int fpm_trace_get_strz(char *buf, size_t sz, long addr) /* {{{ */
+bool fpm_trace_get_strz(char *buf, size_t sz, long addr) /* {{{ */
 {
 	int i;
 	long l = addr;
@@ -15,8 +15,8 @@ int fpm_trace_get_strz(char *buf, size_t sz, long addr) /* {{{ */
 	i = l % SIZEOF_LONG;
 	l -= i;
 	for (addr = l; ; addr += SIZEOF_LONG) {
-		if (0 > fpm_trace_get_long(addr, &l)) {
-			return -1;
+		if (!fpm_trace_get_long(addr, &l)) {
+			return false;
 		}
 		for ( ; i < SIZEOF_LONG; i++) {
 			--sz;
@@ -25,7 +25,7 @@ int fpm_trace_get_strz(char *buf, size_t sz, long addr) /* {{{ */
 				continue;
 			}
 			*buf = '\0';
-			return 0;
+			return true;
 		}
 		i = 0;
 	}
diff --git a/sapi/fpm/fpm/fpm_trace.h b/sapi/fpm/fpm/fpm_trace.h
@@ -3,12 +3,13 @@
 #ifndef FPM_TRACE_H
 #define FPM_TRACE_H 1
 
+#include <stdbool.h>
 #include <unistd.h>
 
-int fpm_trace_signal(pid_t pid);
-int fpm_trace_ready(pid_t pid);
-int fpm_trace_close(pid_t pid);
-int fpm_trace_get_long(long addr, long *data);
-int fpm_trace_get_strz(char *buf, size_t sz, long addr);
+bool fpm_trace_signal(pid_t pid);
+bool fpm_trace_ready(pid_t pid);
+bool fpm_trace_close(pid_t pid);
+bool fpm_trace_get_long(long addr, long *data);
+bool fpm_trace_get_strz(char *buf, size_t sz, long addr);
 
 #endif
diff --git a/sapi/fpm/fpm/fpm_trace_mach.c b/sapi/fpm/fpm/fpm_trace_mach.c
@@ -28,30 +28,30 @@ static void fpm_mach_vm_deallocate(void)
 	}
 }
 
-static int fpm_mach_vm_read_page(vm_offset_t page) /* {{{ */
+static bool fpm_mach_vm_read_page(vm_offset_t page) /* {{{ */
 {
 	kern_return_t kr;
 
 	kr = mach_vm_read(target, page, fpm_pagesize, &local_page, &local_size);
 	if (kr != KERN_SUCCESS) {
 		zlog(ZLOG_ERROR, "failed to read vm page: mach_vm_read(): %s (%d)", mach_error_string(kr), kr);
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_signal(pid_t pid) /* {{{ */
+bool fpm_trace_signal(pid_t pid) /* {{{ */
 {
 	if (0 > fpm_pctl_kill(pid, FPM_PCTL_STOP)) {
 		zlog(ZLOG_SYSERROR, "failed to send SIGSTOP to %d", pid);
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_ready(pid_t pid) /* {{{ */
+bool fpm_trace_ready(pid_t pid) /* {{{ */
 {
 	kern_return_t kr;
 
@@ -63,32 +63,32 @@ int fpm_trace_ready(pid_t pid) /* {{{ */
 			msg = " It seems that master process does not have enough privileges to trace processes.";
 		}
 		zlog(ZLOG_ERROR, "task_for_pid() failed: %s (%d)%s", mach_error_string(kr), kr, msg);
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_close(pid_t pid) /* {{{ */
+bool fpm_trace_close(pid_t pid) /* {{{ */
 {
 	fpm_mach_vm_deallocate();
 	target = 0;
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_get_long(long addr, long *data) /* {{{ */
+bool fpm_trace_get_long(long addr, long *data) /* {{{ */
 {
 	size_t offset = ((uintptr_t) (addr) % fpm_pagesize);
 	vm_offset_t base = (uintptr_t) (addr) - offset;
 
 	if (base != target_page_base) {
 		fpm_mach_vm_deallocate();
-		if (0 > fpm_mach_vm_read_page(base)) {
-			return -1;
+		if (!fpm_mach_vm_read_page(base)) {
+			return false;
 		}
 	}
 	*data = * (long *) (local_page + offset);
-	return 0;
+	return true;
 }
 /* }}} */
diff --git a/sapi/fpm/fpm/fpm_trace_pread.c b/sapi/fpm/fpm/fpm_trace_pread.c
@@ -19,44 +19,44 @@
 
 static int mem_file = -1;
 
-int fpm_trace_signal(pid_t pid) /* {{{ */
+bool fpm_trace_signal(pid_t pid) /* {{{ */
 {
 	if (0 > fpm_pctl_kill(pid, FPM_PCTL_STOP)) {
 		zlog(ZLOG_SYSERROR, "failed to send SIGSTOP to %d", pid);
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_ready(pid_t pid) /* {{{ */
+bool fpm_trace_ready(pid_t pid) /* {{{ */
 {
 	char buf[128];
 
 	sprintf(buf, "/proc/%d/" PROC_MEM_FILE, (int) pid);
 	mem_file = open(buf, O_RDONLY);
 	if (0 > mem_file) {
 		zlog(ZLOG_SYSERROR, "failed to open %s", buf);
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_close(pid_t pid) /* {{{ */
+bool fpm_trace_close(pid_t pid) /* {{{ */
 {
 	close(mem_file);
 	mem_file = -1;
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_get_long(long addr, long *data) /* {{{ */
+bool fpm_trace_get_long(long addr, long *data) /* {{{ */
 {
 	if (sizeof(*data) != pread(mem_file, (void *) data, sizeof(*data), (uintptr_t) addr)) {
 		zlog(ZLOG_SYSERROR, "pread() failed");
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
diff --git a/sapi/fpm/fpm/fpm_trace_ptrace.c b/sapi/fpm/fpm/fpm_trace_ptrace.c
@@ -24,35 +24,35 @@
 
 static pid_t traced_pid;
 
-int fpm_trace_signal(pid_t pid) /* {{{ */
+bool fpm_trace_signal(pid_t pid) /* {{{ */
 {
 	if (0 > ptrace(PTRACE_ATTACH, pid, 0, 0)) {
 		zlog(ZLOG_SYSERROR, "failed to ptrace(ATTACH) child %d", pid);
-		return -1;
+		return false;
 	}
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_ready(pid_t pid) /* {{{ */
+bool fpm_trace_ready(pid_t pid) /* {{{ */
 {
 	traced_pid = pid;
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_close(pid_t pid) /* {{{ */
+bool fpm_trace_close(pid_t pid) /* {{{ */
 {
 	if (0 > ptrace(PTRACE_DETACH, pid, (void *) 1, 0)) {
 		zlog(ZLOG_SYSERROR, "failed to ptrace(DETACH) child %d", pid);
-		return -1;
+		return false;
 	}
 	traced_pid = 0;
-	return 0;
+	return true;
 }
 /* }}} */
 
-int fpm_trace_get_long(long addr, long *data) /* {{{ */
+bool fpm_trace_get_long(long addr, long *data) /* {{{ */
 {
 #ifdef PT_IO
 	struct ptrace_io_desc ptio = {
@@ -64,16 +64,16 @@ int fpm_trace_get_long(long addr, long *data) /* {{{ */
 
 	if (0 > ptrace(PT_IO, traced_pid, (void *) &ptio, 0)) {
 		zlog(ZLOG_SYSERROR, "failed to ptrace(PT_IO) pid %d", traced_pid);
-		return -1;
+		return false;
 	}
 #else
 	errno = 0;
 	*data = ptrace(PTRACE_PEEKDATA, traced_pid, (void *) addr, 0);
 	if (errno) {
 		zlog(ZLOG_SYSERROR, "failed to ptrace(PEEKDATA) pid %d", traced_pid);
-		return -1;
+		return false;
 	}
 #endif
-	return 0;
+	return true;
 }
 /* }}} */

Original file line number	Diff line number	Diff line change
`@@ -52,19 +52,19 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`52`	`52`
`53`	`53`	`fprintf(slowlog, "\n%s [pool %s] pid %d\n", buf, child->wp->config->name, (int) pid);`
`54`	`54`
`55`		`- if (0 > fpm_trace_get_long((long) &SG(request_info).path_translated, &l)) {`
	`55`	`+ if (!fpm_trace_get_long((long) &SG(request_info).path_translated, &l)) {`
`56`	`56`	`return false;`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`path_translated = l;`
`60`	`60`
`61`		`- if (0 > fpm_trace_get_strz(buf, buf_size, path_translated)) {`
	`61`	`+ if (!fpm_trace_get_strz(buf, buf_size, path_translated)) {`
`62`	`62`	`return false;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`fprintf(slowlog, "script_filename = %s\n", buf);`
`66`	`66`
`67`		`- if (0 > fpm_trace_get_long((long) &EG(current_execute_data), &l)) {`
	`67`	`+ if (!fpm_trace_get_long((long) &EG(current_execute_data), &l)) {`
`68`	`68`	`return false;`
`69`	`69`	`}`
`70`	`70`
`@@ -77,22 +77,22 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`77`	`77`	`long prev;`
`78`	`78`	`uint32_t lineno = 0;`
`79`	`79`
`80`		`- if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, func), &l)) {`
	`80`	`+ if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, func), &l)) {`
`81`	`81`	`return false;`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`function = l;`
`85`	`85`
`86`	`86`	`if (valid_ptr(function)) {`
`87`		`- if (0 > fpm_trace_get_long(function + offsetof(zend_function, common.function_name), &l)) {`
	`87`	`+ if (!fpm_trace_get_long(function + offsetof(zend_function, common.function_name), &l)) {`
`88`	`88`	`return false;`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`function_name = l;`
`92`	`92`
`93`	`93`	`if (function_name == 0) {`
`94`	`94`	`uint32_t call_info = (uint32_t )&l;`
`95`		`- if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, This.u1.type_info), &l)) {`
	`95`	`+ if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, This.u1.type_info), &l)) {`
`96`	`96`	`return false;`
`97`	`97`	`}`
`98`	`98`
`@@ -104,7 +104,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`104`	`104`	`ZEND_UNREACHABLE();`
`105`	`105`	`}`
`106`	`106`	`} else {`
`107`		`- if (0 > fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {`
	`107`	`+ if (!fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {`
`108`	`108`	`return false;`
`109`	`109`	`}`
`110`	`110`
`@@ -119,7 +119,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`119`	`119`
`120`	`120`	`*buf = '\0';`
`121`	`121`
`122`		`- if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, prev_execute_data), &l)) {`
	`122`	`+ if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, prev_execute_data), &l)) {`
`123`	`123`	`return false;`
`124`	`124`	`}`
`125`	`125`
`@@ -128,7 +128,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`128`	`128`	`while (prev) {`
`129`	`129`	`zend_uchar *type;`
`130`	`130`
`131`		`- if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, func), &l)) {`
	`131`	`+ if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, func), &l)) {`
`132`	`132`	`return false;`
`133`	`133`	`}`
`134`	`134`
`@@ -139,30 +139,30 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`type = (zend_uchar *)&l;`
`142`		`- if (0 > fpm_trace_get_long(function + offsetof(zend_function, type), &l)) {`
	`142`	`+ if (!fpm_trace_get_long(function + offsetof(zend_function, type), &l)) {`
`143`	`143`	`return false;`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`if (ZEND_USER_CODE(*type)) {`
`147`		`- if (0 > fpm_trace_get_long(function + offsetof(zend_op_array, filename), &l)) {`
	`147`	`+ if (!fpm_trace_get_long(function + offsetof(zend_op_array, filename), &l)) {`
`148`	`148`	`return false;`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`file_name = l;`
`152`	`152`
`153`		`- if (0 > fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {`
	`153`	`+ if (!fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {`
`154`	`154`	`return false;`
`155`	`155`	`}`
`156`	`156`
`157`		`- if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, opline), &l)) {`
	`157`	`+ if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, opline), &l)) {`
`158`	`158`	`return false;`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`if (valid_ptr(l)) {`
`162`	`162`	`long opline = l;`
`163`	`163`	`uint32_t lu = (uint32_t ) &l;`
`164`	`164`
`165`		`- if (0 > fpm_trace_get_long(opline + offsetof(struct _zend_op, lineno), &l)) {`
	`165`	`+ if (!fpm_trace_get_long(opline + offsetof(struct _zend_op, lineno), &l)) {`
`166`	`166`	`return false;`
`167`	`167`	`}`
`168`	`168`
`@@ -171,7 +171,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`171`	`171`	`break;`
`172`	`172`	`}`
`173`	`173`
`174`		`- if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, prev_execute_data), &l)) {`
	`174`	`+ if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, prev_execute_data), &l)) {`
`175`	`175`	`return false;`
`176`	`176`	`}`
`177`	`177`
`@@ -203,15 +203,15 @@ void fpm_php_trace(struct fpm_child_s child) / {{{ */`
`203`	`203`	`goto done0;`
`204`	`204`	`}`
`205`	`205`
`206`		`- if (0 > fpm_trace_ready(child->pid)) {`
	`206`	`+ if (!fpm_trace_ready(child->pid)) {`
`207`	`207`	`goto done1;`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`if (!fpm_php_trace_dump(child, slowlog)) {`
`211`	`211`	`fprintf(slowlog, "+++ dump failed\n");`
`212`	`212`	`}`
`213`	`213`
`214`		`- if (0 > fpm_trace_close(child->pid)) {`
	`214`	`+ if (!fpm_trace_close(child->pid)) {`
`215`	`215`	`goto done1;`
`216`	`216`	`}`
`217`	`217`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`#include "fpm_trace.h"`
`8`	`8`
`9`		`-int fpm_trace_get_strz(char buf, size_t sz, long addr) / {{{ */`
	`9`	`+bool fpm_trace_get_strz(char buf, size_t sz, long addr) / {{{ */`
`10`	`10`	`{`
`11`	`11`	`int i;`
`12`	`12`	`long l = addr;`
`@@ -15,8 +15,8 @@ int fpm_trace_get_strz(char buf, size_t sz, long addr) / {{{ */`
`15`	`15`	`i = l % SIZEOF_LONG;`
`16`	`16`	`l -= i;`
`17`	`17`	`for (addr = l; ; addr += SIZEOF_LONG) {`
`18`		`- if (0 > fpm_trace_get_long(addr, &l)) {`
`19`		`- return -1;`
	`18`	`+ if (!fpm_trace_get_long(addr, &l)) {`
	`19`	`+ return false;`
`20`	`20`	`}`
`21`	`21`	`for ( ; i < SIZEOF_LONG; i++) {`
`22`	`22`	`--sz;`
`@@ -25,7 +25,7 @@ int fpm_trace_get_strz(char buf, size_t sz, long addr) / {{{ */`
`25`	`25`	`continue;`
`26`	`26`	`}`
`27`	`27`	`*buf = '\0';`
`28`		`- return 0;`
	`28`	`+ return true;`
`29`	`29`	`}`
`30`	`30`	`i = 0;`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,30 +28,30 @@ static void fpm_mach_vm_deallocate(void)`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`-static int fpm_mach_vm_read_page(vm_offset_t page) /* {{{ */`
	`31`	`+static bool fpm_mach_vm_read_page(vm_offset_t page) /* {{{ */`
`32`	`32`	`{`
`33`	`33`	`kern_return_t kr;`
`34`	`34`
`35`	`35`	`kr = mach_vm_read(target, page, fpm_pagesize, &local_page, &local_size);`
`36`	`36`	`if (kr != KERN_SUCCESS) {`
`37`	`37`	`zlog(ZLOG_ERROR, "failed to read vm page: mach_vm_read(): %s (%d)", mach_error_string(kr), kr);`
`38`		`- return -1;`
	`38`	`+ return false;`
`39`	`39`	`}`
`40`		`- return 0;`
	`40`	`+ return true;`
`41`	`41`	`}`
`42`	`42`	`/* }}} */`
`43`	`43`
`44`		`-int fpm_trace_signal(pid_t pid) /* {{{ */`
	`44`	`+bool fpm_trace_signal(pid_t pid) /* {{{ */`
`45`	`45`	`{`
`46`	`46`	`if (0 > fpm_pctl_kill(pid, FPM_PCTL_STOP)) {`
`47`	`47`	`zlog(ZLOG_SYSERROR, "failed to send SIGSTOP to %d", pid);`
`48`		`- return -1;`
	`48`	`+ return false;`
`49`	`49`	`}`
`50`		`- return 0;`
	`50`	`+ return true;`
`51`	`51`	`}`
`52`	`52`	`/* }}} */`
`53`	`53`
`54`		`-int fpm_trace_ready(pid_t pid) /* {{{ */`
	`54`	`+bool fpm_trace_ready(pid_t pid) /* {{{ */`
`55`	`55`	`{`
`56`	`56`	`kern_return_t kr;`
`57`	`57`
`@@ -63,32 +63,32 @@ int fpm_trace_ready(pid_t pid) /* {{{ */`
`63`	`63`	`msg = " It seems that master process does not have enough privileges to trace processes.";`
`64`	`64`	`}`
`65`	`65`	`zlog(ZLOG_ERROR, "task_for_pid() failed: %s (%d)%s", mach_error_string(kr), kr, msg);`
`66`		`- return -1;`
	`66`	`+ return false;`
`67`	`67`	`}`
`68`		`- return 0;`
	`68`	`+ return true;`
`69`	`69`	`}`
`70`	`70`	`/* }}} */`
`71`	`71`
`72`		`-int fpm_trace_close(pid_t pid) /* {{{ */`
	`72`	`+bool fpm_trace_close(pid_t pid) /* {{{ */`
`73`	`73`	`{`
`74`	`74`	`fpm_mach_vm_deallocate();`
`75`	`75`	`target = 0;`
`76`		`- return 0;`
	`76`	`+ return true;`
`77`	`77`	`}`
`78`	`78`	`/* }}} */`
`79`	`79`
`80`		`-int fpm_trace_get_long(long addr, long data) / {{{ */`
	`80`	`+bool fpm_trace_get_long(long addr, long data) / {{{ */`
`81`	`81`	`{`
`82`	`82`	`size_t offset = ((uintptr_t) (addr) % fpm_pagesize);`
`83`	`83`	`vm_offset_t base = (uintptr_t) (addr) - offset;`
`84`	`84`
`85`	`85`	`if (base != target_page_base) {`
`86`	`86`	`fpm_mach_vm_deallocate();`
`87`		`- if (0 > fpm_mach_vm_read_page(base)) {`
`88`		`- return -1;`
	`87`	`+ if (!fpm_mach_vm_read_page(base)) {`
	`88`	`+ return false;`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`data = (long *) (local_page + offset);`
`92`		`- return 0;`
	`92`	`+ return true;`
`93`	`93`	`}`
`94`	`94`	`/* }}} */`
Original file line number	Diff line number	Diff line change
`@@ -19,44 +19,44 @@`
`19`	`19`
`20`	`20`	`static int mem_file = -1;`
`21`	`21`
`22`		`-int fpm_trace_signal(pid_t pid) /* {{{ */`
	`22`	`+bool fpm_trace_signal(pid_t pid) /* {{{ */`
`23`	`23`	`{`
`24`	`24`	`if (0 > fpm_pctl_kill(pid, FPM_PCTL_STOP)) {`
`25`	`25`	`zlog(ZLOG_SYSERROR, "failed to send SIGSTOP to %d", pid);`
`26`		`- return -1;`
	`26`	`+ return false;`
`27`	`27`	`}`
`28`		`- return 0;`
	`28`	`+ return true;`
`29`	`29`	`}`
`30`	`30`	`/* }}} */`
`31`	`31`
`32`		`-int fpm_trace_ready(pid_t pid) /* {{{ */`
	`32`	`+bool fpm_trace_ready(pid_t pid) /* {{{ */`
`33`	`33`	`{`
`34`	`34`	`char buf[128];`
`35`	`35`
`36`	`36`	`sprintf(buf, "/proc/%d/" PROC_MEM_FILE, (int) pid);`
`37`	`37`	`mem_file = open(buf, O_RDONLY);`
`38`	`38`	`if (0 > mem_file) {`
`39`	`39`	`zlog(ZLOG_SYSERROR, "failed to open %s", buf);`
`40`		`- return -1;`
	`40`	`+ return false;`
`41`	`41`	`}`
`42`		`- return 0;`
	`42`	`+ return true;`
`43`	`43`	`}`
`44`	`44`	`/* }}} */`
`45`	`45`
`46`		`-int fpm_trace_close(pid_t pid) /* {{{ */`
	`46`	`+bool fpm_trace_close(pid_t pid) /* {{{ */`
`47`	`47`	`{`
`48`	`48`	`close(mem_file);`
`49`	`49`	`mem_file = -1;`
`50`		`- return 0;`
	`50`	`+ return true;`
`51`	`51`	`}`
`52`	`52`	`/* }}} */`
`53`	`53`
`54`		`-int fpm_trace_get_long(long addr, long data) / {{{ */`
	`54`	`+bool fpm_trace_get_long(long addr, long data) / {{{ */`
`55`	`55`	`{`
`56`	`56`	`if (sizeof(data) != pread(mem_file, (void ) data, sizeof(*data), (uintptr_t) addr)) {`
`57`	`57`	`zlog(ZLOG_SYSERROR, "pread() failed");`
`58`		`- return -1;`
	`58`	`+ return false;`
`59`	`59`	`}`
`60`		`- return 0;`
	`60`	`+ return true;`
`61`	`61`	`}`
`62`	`62`	`/* }}} */`
Original file line number	Diff line number	Diff line change
`@@ -24,35 +24,35 @@`
`24`	`24`
`25`	`25`	`static pid_t traced_pid;`
`26`	`26`
`27`		`-int fpm_trace_signal(pid_t pid) /* {{{ */`
	`27`	`+bool fpm_trace_signal(pid_t pid) /* {{{ */`
`28`	`28`	`{`
`29`	`29`	`if (0 > ptrace(PTRACE_ATTACH, pid, 0, 0)) {`
`30`	`30`	`zlog(ZLOG_SYSERROR, "failed to ptrace(ATTACH) child %d", pid);`
`31`		`- return -1;`
	`31`	`+ return false;`
`32`	`32`	`}`
`33`		`- return 0;`
	`33`	`+ return true;`
`34`	`34`	`}`
`35`	`35`	`/* }}} */`
`36`	`36`
`37`		`-int fpm_trace_ready(pid_t pid) /* {{{ */`
	`37`	`+bool fpm_trace_ready(pid_t pid) /* {{{ */`
`38`	`38`	`{`
`39`	`39`	`traced_pid = pid;`
`40`		`- return 0;`
	`40`	`+ return true;`
`41`	`41`	`}`
`42`	`42`	`/* }}} */`
`43`	`43`
`44`		`-int fpm_trace_close(pid_t pid) /* {{{ */`
	`44`	`+bool fpm_trace_close(pid_t pid) /* {{{ */`
`45`	`45`	`{`
`46`	`46`	`if (0 > ptrace(PTRACE_DETACH, pid, (void *) 1, 0)) {`
`47`	`47`	`zlog(ZLOG_SYSERROR, "failed to ptrace(DETACH) child %d", pid);`
`48`		`- return -1;`
	`48`	`+ return false;`
`49`	`49`	`}`
`50`	`50`	`traced_pid = 0;`
`51`		`- return 0;`
	`51`	`+ return true;`
`52`	`52`	`}`
`53`	`53`	`/* }}} */`
`54`	`54`
`55`		`-int fpm_trace_get_long(long addr, long data) / {{{ */`
	`55`	`+bool fpm_trace_get_long(long addr, long data) / {{{ */`
`56`	`56`	`{`
`57`	`57`	`#ifdef PT_IO`
`58`	`58`	`struct ptrace_io_desc ptio = {`
`@@ -64,16 +64,16 @@ int fpm_trace_get_long(long addr, long data) / {{{ */`
`64`	`64`
`65`	`65`	`if (0 > ptrace(PT_IO, traced_pid, (void *) &ptio, 0)) {`
`66`	`66`	`zlog(ZLOG_SYSERROR, "failed to ptrace(PT_IO) pid %d", traced_pid);`
`67`		`- return -1;`
	`67`	`+ return false;`
`68`	`68`	`}`
`69`	`69`	`#else`
`70`	`70`	`errno = 0;`
`71`	`71`	`data = ptrace(PTRACE_PEEKDATA, traced_pid, (void ) addr, 0);`
`72`	`72`	`if (errno) {`
`73`	`73`	`zlog(ZLOG_SYSERROR, "failed to ptrace(PEEKDATA) pid %d", traced_pid);`
`74`		`- return -1;`
	`74`	`+ return false;`
`75`	`75`	`}`
`76`	`76`	`#endif`
`77`		`- return 0;`
	`77`	`+ return true;`
`78`	`78`	`}`
`79`	`79`	`/* }}} */`