Convert return values to bool in fpm_trace.c files

Girgias · Girgias · commit 92d5d1929173 · 2022-11-08T16:10:28.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
@@ -51,19 +51,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;
 	}
 
@@ -76,22 +76,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;
 				}
 
@@ -103,7 +103,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;
 				}
 
@@ -118,7 +118,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;
 		}
 
@@ -127,7 +127,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;
 			}
 
@@ -138,30 +138,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;
 					}
 
@@ -170,7 +170,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;
 			}
 
@@ -202,15 +202,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
@@ -5,10 +5,10 @@
 
 #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
`@@ -51,19 +51,19 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`51`	`51`
`52`	`52`	`fprintf(slowlog, "\n%s [pool %s] pid %d\n", buf, child->wp->config->name, (int) pid);`
`53`	`53`
`54`		`- if (0 > fpm_trace_get_long((long) &SG(request_info).path_translated, &l)) {`
	`54`	`+ if (!fpm_trace_get_long((long) &SG(request_info).path_translated, &l)) {`
`55`	`55`	`return false;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`path_translated = l;`
`59`	`59`
`60`		`- if (0 > fpm_trace_get_strz(buf, buf_size, path_translated)) {`
	`60`	`+ if (!fpm_trace_get_strz(buf, buf_size, path_translated)) {`
`61`	`61`	`return false;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`fprintf(slowlog, "script_filename = %s\n", buf);`
`65`	`65`
`66`		`- if (0 > fpm_trace_get_long((long) &EG(current_execute_data), &l)) {`
	`66`	`+ if (!fpm_trace_get_long((long) &EG(current_execute_data), &l)) {`
`67`	`67`	`return false;`
`68`	`68`	`}`
`69`	`69`
`@@ -76,22 +76,22 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`76`	`76`	`long prev;`
`77`	`77`	`uint32_t lineno = 0;`
`78`	`78`
`79`		`- if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, func), &l)) {`
	`79`	`+ if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, func), &l)) {`
`80`	`80`	`return false;`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`function = l;`
`84`	`84`
`85`	`85`	`if (valid_ptr(function)) {`
`86`		`- if (0 > fpm_trace_get_long(function + offsetof(zend_function, common.function_name), &l)) {`
	`86`	`+ if (!fpm_trace_get_long(function + offsetof(zend_function, common.function_name), &l)) {`
`87`	`87`	`return false;`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`function_name = l;`
`91`	`91`
`92`	`92`	`if (function_name == 0) {`
`93`	`93`	`uint32_t call_info = (uint32_t )&l;`
`94`		`- if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, This.u1.type_info), &l)) {`
	`94`	`+ if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, This.u1.type_info), &l)) {`
`95`	`95`	`return false;`
`96`	`96`	`}`
`97`	`97`
`@@ -103,7 +103,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`103`	`103`	`ZEND_UNREACHABLE();`
`104`	`104`	`}`
`105`	`105`	`} else {`
`106`		`- if (0 > fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {`
	`106`	`+ if (!fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {`
`107`	`107`	`return false;`
`108`	`108`	`}`
`109`	`109`
`@@ -118,7 +118,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`118`	`118`
`119`	`119`	`*buf = '\0';`
`120`	`120`
`121`		`- if (0 > fpm_trace_get_long(execute_data + offsetof(zend_execute_data, prev_execute_data), &l)) {`
	`121`	`+ if (!fpm_trace_get_long(execute_data + offsetof(zend_execute_data, prev_execute_data), &l)) {`
`122`	`122`	`return false;`
`123`	`123`	`}`
`124`	`124`
`@@ -127,7 +127,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`127`	`127`	`while (prev) {`
`128`	`128`	`zend_uchar *type;`
`129`	`129`
`130`		`- if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, func), &l)) {`
	`130`	`+ if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, func), &l)) {`
`131`	`131`	`return false;`
`132`	`132`	`}`
`133`	`133`
`@@ -138,30 +138,30 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`type = (zend_uchar *)&l;`
`141`		`- if (0 > fpm_trace_get_long(function + offsetof(zend_function, type), &l)) {`
	`141`	`+ if (!fpm_trace_get_long(function + offsetof(zend_function, type), &l)) {`
`142`	`142`	`return false;`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`if (ZEND_USER_CODE(*type)) {`
`146`		`- if (0 > fpm_trace_get_long(function + offsetof(zend_op_array, filename), &l)) {`
	`146`	`+ if (!fpm_trace_get_long(function + offsetof(zend_op_array, filename), &l)) {`
`147`	`147`	`return false;`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`file_name = l;`
`151`	`151`
`152`		`- if (0 > fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {`
	`152`	`+ if (!fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {`
`153`	`153`	`return false;`
`154`	`154`	`}`
`155`	`155`
`156`		`- if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, opline), &l)) {`
	`156`	`+ if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, opline), &l)) {`
`157`	`157`	`return false;`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`if (valid_ptr(l)) {`
`161`	`161`	`long opline = l;`
`162`	`162`	`uint32_t lu = (uint32_t ) &l;`
`163`	`163`
`164`		`- if (0 > fpm_trace_get_long(opline + offsetof(struct _zend_op, lineno), &l)) {`
	`164`	`+ if (!fpm_trace_get_long(opline + offsetof(struct _zend_op, lineno), &l)) {`
`165`	`165`	`return false;`
`166`	`166`	`}`
`167`	`167`
`@@ -170,7 +170,7 @@ static bool fpm_php_trace_dump(struct fpm_child_s child, FILE slowlog) /* {{{`
`170`	`170`	`break;`
`171`	`171`	`}`
`172`	`172`
`173`		`- if (0 > fpm_trace_get_long(prev + offsetof(zend_execute_data, prev_execute_data), &l)) {`
	`173`	`+ if (!fpm_trace_get_long(prev + offsetof(zend_execute_data, prev_execute_data), &l)) {`
`174`	`174`	`return false;`
`175`	`175`	`}`
`176`	`176`
`@@ -202,15 +202,15 @@ void fpm_php_trace(struct fpm_child_s child) / {{{ */`
`202`	`202`	`goto done0;`
`203`	`203`	`}`
`204`	`204`
`205`		`- if (0 > fpm_trace_ready(child->pid)) {`
	`205`	`+ if (!fpm_trace_ready(child->pid)) {`
`206`	`206`	`goto done1;`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`if (!fpm_php_trace_dump(child, slowlog)) {`
`210`	`210`	`fprintf(slowlog, "+++ dump failed\n");`
`211`	`211`	`}`
`212`	`212`
`213`		`- if (0 > fpm_trace_close(child->pid)) {`
	`213`	`+ if (!fpm_trace_close(child->pid)) {`
`214`	`214`	`goto done1;`
`215`	`215`	`}`
`216`	`216`
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`	`/* }}} */`