Merge pull request #40 from GBuella/mmap_fix

Fixes related to calling syscall_no_intercept

Author: Sarah Jelinek

doc/generated/libsyscall_intercept.3

@@ -98,17 +98,32 @@ after a clone syscall creating a thread returns in a child thread:
 .IP
 .nf
 \f[C]
-long\ (*intercept_hook_point_clone_child)(void);
+void\ (*intercept_hook_point_clone_child)(void);
 \f[]
 .fi
 .PP
 Using \f[C]intercept_hook_point_clone_child\f[], one can be notified of
-thread creations easily, and even override the syscall\[aq]s return
-value in the child thread (which is normally zero).
-Note: overriding the zero return value is discouraged \-\- this syscall
-is usually issued by libc, and a non\-zero return value is interpreted
-as the execution remaining in the parent thread, thus using attempting
-to use the same stack space as the actual parent thread.
+thread creations.
+.PP
+To make it easy to detect syscall return values indicating errors, one
+can use the syscall_error_code function:
+.IP
+.nf
+\f[C]
+int\ syscall_error_code(long\ result);
+\f[]
+.fi
+.PP
+When passed a return value from syscall_no_intercept, this function can
+translate it to an error code equivalent to a libc error code:
+.IP
+.nf
+\f[C]
+int\ fd\ =\ (int)syscall_no_intercept(SYS_open,\ "file",\ O_RDWR);
+if\ (syscall_error_code(fd)\ !=\ 0)
+\ \ \ \ fprintf(stderr,\ strerror(syscall_error_code(fd)));
+\f[]
+.fi
 .SH ENVIRONMENT VARIABLES
 .PP
 Three environment variables control the operation of the library:

doc/libsyscall_intercept.3.md

@@ -101,6 +101,19 @@ void (*intercept_hook_point_clone_child)(void);
 Using `intercept_hook_point_clone_child`, one can be notified of thread
 creations.
 
+To make it easy to detect syscall return values indicating errors, one
+can use the syscall_error_code function:
+```c
+int syscall_error_code(long result);
+```
+When passed a return value from syscall_no_intercept, this function
+can translate it to an error code equivalent to a libc error code:
+```c
+int fd = (int)syscall_no_intercept(SYS_open, "file", O_RDWR);
+if (syscall_error_code(fd) != 0)
+	fprintf(stderr, strerror(syscall_error_code(fd)));
+```
+
 # ENVIRONMENT VARIABLES #
 Three environment variables control the operation of the library:
 

examples/syscall_logger.c

@@ -45,7 +45,7 @@
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 
-long log_fd;
+int log_fd;
 
 static char buffer[0x20000];
 static size_t buffer_offset;
@@ -849,7 +849,8 @@ start(void)
 	if (path == NULL)
 		syscall_no_intercept(SYS_exit_group, 3);
 
-	log_fd = syscall_no_intercept(SYS_open, path, O_CREAT | O_RDWR, 0700);
+	log_fd = (int)syscall_no_intercept(SYS_open,
+			path, O_CREAT | O_RDWR, (mode_t)0700);
 
 	if (log_fd < 0)
 		syscall_no_intercept(SYS_exit_group, 4);

include/libsyscall_intercept_hook_point.h

@@ -69,6 +69,20 @@ extern void (*intercept_hook_point_clone_child)(void);
  */
 long syscall_no_intercept(long syscall_number, ...);
 
+/*
+ * syscall_error_code - examines a return value from
+ * syscall_no_intercept, and returns an error code if said
+ * return value indicates an error.
+ */
+static inline int
+syscall_error_code(long result)
+{
+	if (result < 0 && result >= -0x1000)
+		return (int)-result;
+
+	return 0;
+}
+
 /*
  * The syscall intercepting library checks for the
  * INTERCEPT_HOOK_CMDLINE_FILTER environment variable, with which one can

src/entry.c

@@ -66,7 +66,7 @@ entry_point(void)
  * chars at a time. See syscall_hook_in_process_allowed below.
  */
 static bool
-match_with_file_end(const char *expected, long fd)
+match_with_file_end(const char *expected, int fd)
 {
 	char file_c; /* next character from file */
 	const char *c; /* next character from the expected string */
@@ -76,7 +76,8 @@ match_with_file_end(const char *expected, long fd)
 
 	c = expected;
 
-	while (syscall_no_intercept(SYS_read, fd, &file_c, 1) == 1) {
+	while (syscall_no_intercept(SYS_read, fd, &file_c, (size_t)1)
+			== (ssize_t)1) {
 		if (file_c == '\0') /* this probably never happens */
 			break;
 
@@ -98,15 +99,16 @@ match_with_file_end(const char *expected, long fd)
 int
 syscall_hook_in_process_allowed(void)
 {
-	long fd;
+	int fd;
 	bool result;
 	const char *filter;
 
 	filter = getenv("INTERCEPT_HOOK_CMDLINE_FILTER");
 	if (filter == NULL)
 		return 1;
 
-	fd = syscall_no_intercept(SYS_open, "/proc/self/cmdline", O_RDONLY, 0);
+	fd = (int)syscall_no_intercept(SYS_open,
+			"/proc/self/cmdline", O_RDONLY, (mode_t)0);
 
 	if (fd < 0)
 		return 0;

src/intercept.c

@@ -448,21 +448,65 @@ log_header(void)
 }
 
 /*
- * xabort - speaks for itself
+ * xabort_errno - print a message to stderr, and exit the process.
  * Calling abort() in libc might result other syscalls being called
  * by libc.
+ *
+ * If error_code is not zero, it is also printed.
  */
 void
-xabort(const char *msg)
+xabort_errno(int error_code, const char *msg)
 {
 	static const char main_msg[] = " libsyscall_intercept error\n";
 
-	if (msg != NULL)
-		syscall_no_intercept(SYS_write, 2, msg, strlen(msg));
-	syscall_no_intercept(SYS_write, 2, main_msg, sizeof(main_msg));
+	if (msg != NULL) {
+		/* not using libc - inline strlen */
+		size_t len = 0;
+		while (msg[len] != '\0')
+			++len;
+		syscall_no_intercept(SYS_write, 2, msg, len);
+	}
+
+	if (error_code != 0) {
+		char buf[0x10];
+		size_t len = 1;
+		char *c = buf + sizeof(buf) - 1;
+
+		/* not using libc - inline sprintf */
+		do {
+			*c-- = error_code % 10;
+			++len;
+			error_code /= 10;
+		} while (error_code != 0);
+		*c = ' ';
+
+		syscall_no_intercept(SYS_write, 2, c, len);
+	}
+
+	syscall_no_intercept(SYS_write, 2, main_msg, sizeof(main_msg) - 1);
 	syscall_no_intercept(SYS_exit_group, 1);
 
-	__builtin_trap();
+	__builtin_unreachable();
+}
+
+/*
+ * xabort - print a message to stderr, and exit the process.
+ */
+void
+xabort(const char *msg)
+{
+	xabort_errno(0, msg);
+}
+
+/*
+ * xabort_on_syserror -- examines the return value of syscall_no_intercept,
+ * and calls xabort_errno if the said return value indicates an error.
+ */
+void
+xabort_on_syserror(long syscall_result, const char *msg)
+{
+	if (syscall_error_code(syscall_result) != 0)
+		xabort_errno(syscall_error_code(syscall_result), msg);
 }
 
 /*

src/intercept.h

@@ -62,7 +62,11 @@ void intercept_patch_with_postfix(unsigned char *syscall_addr,
 
 #define INTERCEPTOR_EXIT_CODE 111
 
-__attribute__((noreturn)) void xabort(const char *);
+__attribute__((noreturn)) void xabort_errno(int error_code, const char *msg);
+
+__attribute__((noreturn)) void xabort(const char *msg);
+
+void xabort_on_syserror(long syscall_result, const char *msg);
 
 struct range {
 	unsigned char *address;

src/intercept_desc.c

@@ -57,18 +57,14 @@
  * only be present in the original file.
  * Note on naming: memory has segments, the object file has sections.
  */
-static long
+static int
 open_orig_file(const struct intercept_desc *desc)
 {
-	long fd;
+	int fd;
 
 	fd = syscall_no_intercept(SYS_open, desc->path, O_RDONLY);
 
-	if (fd < 0) {
-		syscall_no_intercept(SYS_write, 2,
-		    desc->path, strlen(desc->path));
-		xabort(" open_orig_file");
-	}
+	xabort_on_syserror(fd, __func__);
 
 	return fd;
 }
@@ -106,7 +102,7 @@ add_text_info(struct intercept_desc *desc, const Elf64_Shdr *header,
  * See: man elf
  */
 static void
-find_sections(struct intercept_desc *desc, long fd)
+find_sections(struct intercept_desc *desc, int fd)
 {
 	Elf64_Ehdr elf_header;
 
@@ -293,7 +289,7 @@ mark_jump(const struct intercept_desc *desc, const unsigned char *addr)
  */
 static void
 find_jumps_in_section_syms(struct intercept_desc *desc, Elf64_Shdr *section,
-				long fd)
+				int fd)
 {
 	assert(section->sh_type == SHT_SYMTAB ||
 		section->sh_type == SHT_DYNSYM);
@@ -344,7 +340,7 @@ find_jumps_in_section_syms(struct intercept_desc *desc, Elf64_Shdr *section,
  */
 static void
 find_jumps_in_section_rela(struct intercept_desc *desc, Elf64_Shdr *section,
-				long fd)
+				int fd)
 {
 	assert(section->sh_type == SHT_RELA);
 
@@ -691,7 +687,7 @@ find_syscalls(struct intercept_desc *desc)
 
 	desc->count = 0;
 
-	long fd = open_orig_file(desc);
+	int fd = open_orig_file(desc);
 
 	find_sections(desc, fd);
 	debug_dump(

src/intercept_util.c

@@ -32,6 +32,7 @@
 
 #include "intercept_util.h"
 #include "intercept.h"
+#include "libsyscall_intercept_hook_point.h"
 
 #include <assert.h>
 #include <inttypes.h>
@@ -48,58 +49,57 @@
 #include <sched.h>
 #include <linux/limits.h>
 
-static long log_fd = -1;
+static int log_fd = -1;
 
 void *
 xmmap_anon(size_t size)
 {
-	void *addr = (void *) syscall_no_intercept(SYS_mmap,
+	long addr = syscall_no_intercept(SYS_mmap,
 				NULL, size,
 				PROT_READ | PROT_WRITE,
-				MAP_PRIVATE | MAP_ANON, -1, 0);
+				MAP_PRIVATE | MAP_ANON, -1, (off_t)0);
 
-	if (addr == MAP_FAILED)
-		xabort("xmmap_anon");
+	xabort_on_syserror(addr, __func__);
 
-	return addr;
+	return (void *) addr;
 }
 
 void *
 xmremap(void *addr, size_t old, size_t new)
 {
-	addr = (void *) syscall_no_intercept(SYS_mremap, addr,
+	long new_addr = syscall_no_intercept(SYS_mremap, addr,
 				old, new, MREMAP_MAYMOVE);
 
-	if (addr == MAP_FAILED)
-		xabort("xmremap");
+	xabort_on_syserror(new_addr, __func__);
 
-	return addr;
+	return (void *) new_addr;
 }
 
 void
 xmunmap(void *addr, size_t len)
 {
-	if (syscall_no_intercept(SYS_munmap, addr, len) != 0)
-		xabort("xmunmap");
+	long result = syscall_no_intercept(SYS_munmap, addr, len);
+
+	xabort_on_syserror(result, __func__);
 }
 
 long
 xlseek(long fd, unsigned long off, int whence)
 {
 	long result = syscall_no_intercept(SYS_lseek, fd, off, whence);
 
-	if (result < 0)
-		xabort("xlseek");
+	xabort_on_syserror(result, __func__);
 
 	return result;
 }
 
 void
 xread(long fd, void *buffer, size_t size)
 {
-	if (syscall_no_intercept(SYS_read, fd,
-	    (long)buffer, (long)size) != (long)size)
-		xabort("xread");
+	long result = syscall_no_intercept(SYS_read, fd, buffer, size);
+
+	if (result != (long)size)
+		xabort_errno(syscall_error_code(result), __func__);
 }
 
 /*
@@ -130,10 +130,9 @@ intercept_setup_log(const char *path_base, const char *trunc)
 
 	intercept_log_close();
 
-	log_fd = syscall_no_intercept(SYS_open, path, flags, 0700);
+	log_fd = (int)syscall_no_intercept(SYS_open, path, flags, (mode_t)0700);
 
-	if (log_fd < 0)
-		xabort("setup_log");
+	xabort_on_syserror(log_fd, "opening log");
 }
 
 /*
@@ -1520,7 +1519,7 @@ intercept_log(const char *buffer, size_t len)
 {
 	if (log_fd >= 0)
 		syscall_no_intercept(SYS_write, log_fd,
-		    (long)buffer, (long)len);
+		    buffer, len);
 }
 
 /*