Changeset 1a3b953 in mainline for uspace/lib/bithenge/failure.c

Timestamp:

2012-08-20T00:22:19Z (13 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0784869

Parents:

5e514c0

Message:

Bithenge: better error injection

File:

• uspace/lib/bithenge/failure.c (modified) (12 diffs)

uspace/lib/bithenge/failure.c

@@ -36 +36 @@
 
 #include <errno.h>
+#include <execinfo.h>
 #include <fcntl.h>
 #include <stdio.h>
@@ -45 +46 @@
 #define BITHENGE_FAILURE_DECLS_ONLY 1
 #include "failure.h"
+#include "os.h"
 
 /* This file raises fake errors from system calls, to test that Bithenge
@@ -54 +56 @@
  * correctly (exit code is 1), the main process continues without errors. If
  * the child process has a problem, the main process raises the fake error
- * again and shows all stdout and stderr output. For speed, failures only occur
- * for some system calls after the first 128.
+ * again and shows all stdout and stderr output. For speed, errors are only
+ * raised when part of the backtrace has not been seen before.
  *
  * BITHENGE_FAILURE_INDEX set: the program runs normally until system call
@@ -61 +63 @@
  * call. */
 
+static int g_initialized = 0;
 static int g_failure_index = -1;
-static int g_failure_index_selected = -2;
-
-static int should_fail(void)
+static int g_failure_index_selected = -1;
+
+typedef struct backtrace_item {
+        struct backtrace_item *next;
+        void *backtrace_item;
+} backtrace_item_t;
+
+static backtrace_item_t *g_backtrace_items = NULL;
+
+static void atexit_handler(void)
+{
+        while (g_backtrace_items) {
+                backtrace_item_t *first = g_backtrace_items;
+                g_backtrace_items = first->next;
+                free(first);
+        }
+}
+
+static inline void initialize(void)
+{
+        g_initialized = 1;
+        int rc = atexit(atexit_handler);
+        if (rc)
+                exit(127);
+
+        char *sel_str = getenv("BITHENGE_FAILURE_INDEX");
+        if (sel_str)
+                g_failure_index_selected = strtol(sel_str, NULL, 10);
+}
+
+/* Record a hit for a backtrace address and return whether this is the first
+ * hit. */
+static inline int backtrace_item_hit(void *addr)
+{
+        backtrace_item_t **bip;
+        for (bip = &g_backtrace_items; *bip; bip = &(*bip)->next) {
+                backtrace_item_t *bi = *bip;
+                if (bi->backtrace_item == addr) {
+                        /* Keep frequently accessed items near the front. */
+                        *bip = bi->next;
+                        bi->next = g_backtrace_items;
+                        g_backtrace_items = bi;
+                        return 0;
+                }
+        }
+
+        /* No item found; create one. */
+        backtrace_item_t *i = malloc(sizeof(*i));
+        if (!i)
+                exit(127);
+        i->next = g_backtrace_items;
+        i->backtrace_item = addr;
+        g_backtrace_items = i;
+        return 1;
+}
+
+int bithenge_should_fail(void)
 {
         g_failure_index++;
 
-        if (g_failure_index_selected == -2) {
-                char *sel_str = getenv("BITHENGE_FAILURE_INDEX");
-                if (sel_str) {
-                        g_failure_index_selected = strtol(sel_str, NULL, 10);
-                } else {
-                        g_failure_index_selected = -1;
-                }
-        } else if (g_failure_index_selected != -1) {
+        if (!g_initialized)
+                initialize();
+
+        if (g_failure_index_selected != -1) {
                 if (g_failure_index == g_failure_index_selected)
                         return 1; /* breakpoint here */
@@ -81 +134 @@
         }
 
-        /* Only fail half the time after 128 failures, 1/4 the time after 256
-         * failures, 1/8 the time after 512 failures... */
-        int index = g_failure_index;
-        while (index >= 128) {
-                int test = (index & (64 | 1));
-                if (test == (64 | 1) || test == 0)
-                        return 0;
-                index >>= 1;
-        }
+        /* If all backtrace items have been seen already, there's no need to
+         * try raising an error. */
+        void *trace[256];
+        int size = backtrace(trace, 256);
+        int raise_error = 0;
+        for (int i = 0; i < size; i++) {
+                if (backtrace_item_hit(trace[i]))
+                        raise_error = 1;
+        }
+        if (!raise_error)
+                return 0;
 
         if (!fork()) {
-                /* Child */
+                /* Child silently fails. */
                 int null = open("/dev/null", O_WRONLY);
                 if (null == -1)
@@ -102 +157 @@
         }
 
-        /* Parent */
+        /* Parent checks whether child failed correctly. */
         int status;
         wait(&status);
@@ -108 +163 @@
                 return 0;
 
-        /* The child had an error! We couldn't see it because stdout and stderr
-         * were redirected, and we couldn't debug it easily because it was a
-         * separate process. Do it again without redirecting or forking. */
+        /* The child had an error! We couldn't easily debug it because it was
+         * in a separate process with redirected stdout and stderr. Do it again
+         * without redirecting or forking. */
         fprintf(stderr, "** Fake error raised here (BITHENGE_FAILURE_INDEX=%d)\n",
             g_failure_index);
@@ -118 +173 @@
 void *bithenge_failure_malloc(size_t size)
 {
-        if (should_fail())
+        if (bithenge_should_fail())
                 return NULL;
         return malloc(size);
@@ -125 +180 @@
 void *bithenge_failure_realloc(void *ptr, size_t size)
 {
-        if (should_fail())
+        if (bithenge_should_fail())
                 return NULL;
         return realloc(ptr, size);
@@ -132 +187 @@
 ssize_t bithenge_failure_read(int fd, void *buf, size_t count)
 {
-        if (should_fail()) {
+        if (bithenge_should_fail()) {
                 errno = EIO;
                 return -1;
@@ -141 +196 @@
 off_t bithenge_failure_lseek(int fd, off_t offset, int whither)
 {
-        if (should_fail()) {
+        if (bithenge_should_fail()) {
                 errno = EINVAL;
                 return (off_t) -1;
@@ -148 +203 @@
 }
 
+int bithenge_failure_ferror(FILE *stream)
+{
+        if (bithenge_should_fail())
+                return 1;
+        return ferror(stream);
+}
+
+char *bithenge_failure_str_ndup(const char *s, size_t max_len)
+{
+        if (bithenge_should_fail())
+                return NULL;
+        return str_ndup(s, max_len);
+}
+
+int bithenge_failure_open(const char *pathname, int flags)
+{
+        if (bithenge_should_fail()) {
+                errno = EACCES;
+                return -1;
+        }
+        return open(pathname, flags);
+}
+
+int bithenge_failure_fstat(int fd, struct stat *buf)
+{
+        if (bithenge_should_fail()) {
+                errno = EIO;
+                return -1;
+        }
+        return fstat(fd, buf);
+}
+
 /** @}
  */