ciniparser: fix ctype.h usage, and lazy strrchr.
[ccan] / ccan / failtest / failtest.c
index 2df1ae668e01e06318f535a2fa5f3a75466968cf..3f64bc91b512e35cb05a812979118ee06b9b1280 100644 (file)
@@ -1,3 +1,4 @@
+#include "config.h"
 #include <stdarg.h>
 #include <string.h>
 #include <stdio.h>
 #include <ccan/failtest/failtest.h>
 #include <ccan/build_assert/build_assert.h>
 
-bool (*failtest_hook)(struct failtest_call *history, unsigned num)
-= failtest_default_hook;
+enum failtest_result (*failtest_hook)(struct failtest_call *, unsigned);
 
 static int tracefd = -1;
 
 unsigned int failtest_timeout_ms = 20000;
 
 const char *failpath;
+const char *debugpath;
 
 enum info_type {
        WRITE,
@@ -47,6 +48,7 @@ static struct failtest_call *history = NULL;
 static unsigned int history_num = 0;
 static int control_fd = -1;
 static struct timeval start;
+static unsigned int probe_count = 0;
 
 static struct write_call *child_writes = NULL;
 static unsigned int child_writes_num = 0;
@@ -55,7 +57,7 @@ static pid_t lock_owner;
 static struct lock_info *locks = NULL;
 static unsigned int lock_num = 0;
 
-static const char info_to_arg[] = "mceoprwf";
+static const char info_to_arg[] = "mceoxprwf";
 
 /* Dummy call used for failtest_undo wrappers. */
 static struct failtest_call unrecorded_call;
@@ -85,11 +87,6 @@ static struct failtest_call *add_history_(enum failtest_call_type type,
 #define set_cleanup(call, clean, type)                 \
        (call)->cleanup = (void *)((void)sizeof(clean((type *)NULL)), (clean))
 
-bool failtest_default_hook(struct failtest_call *history, unsigned num)
-{
-       return true;
-}
-
 static bool read_write_info(int fd)
 {
        struct write_call *w;
@@ -146,11 +143,23 @@ static void child_fail(const char *out, size_t outlen, const char *fmt, ...)
        exit(1);
 }
 
+static void trace(const char *fmt, ...)
+{
+       va_list ap;
+
+       if (tracefd == -1)
+               return;
+
+       va_start(ap, fmt);
+       vdprintf(tracefd, fmt, ap);
+       va_end(ap);
+}
+
 static pid_t child;
 
-static void hand_down(int signal)
+static void hand_down(int signum)
 {
-       kill(child, signal);
+       kill(child, signum);
 }
 
 static void release_locks(void)
@@ -219,16 +228,118 @@ static void get_locks(void)
        lock_owner = getpid();
 }
 
-static void trace_str(const char *str)
+struct saved_file {
+       struct saved_file *next;
+       int fd;
+       void *contents;
+       off_t off, len;
+};
+
+static struct saved_file *save_file(struct saved_file *next, int fd)
 {
-       ssize_t ret;
+       struct saved_file *s = malloc(sizeof(*s));
+
+       s->next = next;
+       s->fd = fd;
+       s->off = lseek(fd, 0, SEEK_CUR);
+       /* Special file?  Erk... */
+       assert(s->off != -1);
+       s->len = lseek(fd, 0, SEEK_END);
+       lseek(fd, 0, SEEK_SET);
+       s->contents = malloc(s->len);
+       read(fd, s->contents, s->len);
+       lseek(fd, s->off, SEEK_SET);
+       return s;
+}
+       
+/* We have little choice but to save and restore open files: mmap means we
+ * can really intercept changes in the child.
+ *
+ * We could do non-mmap'ed files on demand, however. */
+static struct saved_file *save_files(void)
+{
+       struct saved_file *files = NULL;
+       int i;
+
+       /* Figure out the set of live fds. */
+       for (i = history_num - 2; i >= 0; i--) {
+               if (history[i].type == FAILTEST_OPEN) {
+                       int fd = history[i].u.open.ret;
+                       /* Only do successful, writable fds. */
+                       if (fd < 0)
+                               continue;
 
-       while ((ret = write(tracefd, str, strlen(str))) <= 0) {
-               str += ret;
-               if (!*str)
-                       return;
+                       /* If it was closed, cleanup == NULL. */
+                       if (!history[i].cleanup)
+                               continue;
+
+                       if ((history[i].u.open.flags & O_RDWR) == O_RDWR) {
+                               files = save_file(files, fd);
+                       } else if ((history[i].u.open.flags & O_WRONLY)
+                                  == O_WRONLY) {
+                               /* FIXME: Handle O_WRONLY.  Open with O_RDWR? */
+                               abort();
+                       }
+               }
        }
-       err(1, "Writing trace.");
+
+       return files;
+}
+
+static void restore_files(struct saved_file *s)
+{
+       while (s) {
+               struct saved_file *next = s->next;
+
+               lseek(s->fd, 0, SEEK_SET);
+               write(s->fd, s->contents, s->len);
+               ftruncate(s->fd, s->len);
+               free(s->contents);
+               lseek(s->fd, s->off, SEEK_SET);
+               free(s);
+               s = next;
+       }
+}
+
+/* Free up memory, so valgrind doesn't report leaks. */
+static void free_everything(void)
+{
+       unsigned int i;
+
+       /* We don't do this in cleanup: needed even for failed opens. */
+       for (i = 0; i < history_num; i++) {
+               if (history[i].type == FAILTEST_OPEN)
+                       free((char *)history[i].u.open.pathname);
+       }
+       free(history);
+}
+
+static NORETURN void failtest_cleanup(bool forced_cleanup, int status)
+{
+       int i;
+
+       /* For children, we don't care if they "failed" the testing. */
+       if (control_fd != -1)
+               status = 0;
+
+       if (forced_cleanup)
+               history_num--;
+
+       /* Cleanup everything, in reverse order. */
+       for (i = history_num - 1; i >= 0; i--) {
+               if (!history[i].cleanup)
+                       continue;
+               if (!forced_cleanup) {
+                       printf("Leak at %s:%u\n",
+                              history[i].file, history[i].line);
+                       status = 1;
+               }
+               history[i].cleanup(&history[i].u);
+       }
+
+       free_everything();
+       tell_parent(SUCCESS);
+       exit(status);
 }
 
 static bool should_fail(struct failtest_call *call)
@@ -238,6 +349,11 @@ static bool should_fail(struct failtest_call *call)
        enum info_type type = UNEXPECTED;
        char *out = NULL;
        size_t outlen = 0;
+       struct saved_file *files;
+
+       /* Are we probing? */
+       if (probe_count && --probe_count == 0)
+               failtest_cleanup(true, 0);
 
        if (call == &unrecorded_call)
                return false;
@@ -247,19 +363,60 @@ static bool should_fail(struct failtest_call *call)
                if (*failpath == '+')
                        failpath = NULL;
                else {
-                       if (tolower(*failpath) != info_to_arg[call->type])
+                       if (tolower((unsigned char)*failpath)
+                           != info_to_arg[call->type])
                                errx(1, "Failpath expected '%c' got '%c'\n",
                                     info_to_arg[call->type], *failpath);
-                       call->fail = isupper(*(failpath++));
+                       call->fail = isupper((unsigned char)*(failpath++));
                        return call->fail;
                }
        }
 
-       if (!failtest_hook(history, history_num)) {
-               call->fail = false;
-               return false;
+       /* Attach debugger if they asked for it. */
+       if (debugpath && history_num == strlen(debugpath)) {
+               unsigned int i;
+
+               for (i = 0; i < history_num; i++) {
+                       unsigned char c = info_to_arg[history[i].type];
+                       if (history[i].fail)
+                               c = toupper(c);
+                       if (c != debugpath[i])
+                               break;
+               }
+               if (i == history_num) {
+                       char str[80];
+
+                       /* Don't timeout. */
+                       signal(SIGUSR1, SIG_IGN);
+                       sprintf(str, "xterm -e gdb /proc/%d/exe %d &",
+                               getpid(), getpid());
+                       system(str);
+                       sleep(5);
+               }
        }
 
+       if (failtest_hook) {
+               switch (failtest_hook(history, history_num)) {
+               case FAIL_OK:
+                       break;
+               case FAIL_DONT_FAIL:
+                       call->fail = false;
+                       return false;
+               case FAIL_PROBE:
+                       /* Already down probe path?  Stop now. */
+                       if (probe_count)
+                               failtest_cleanup(true, 0);
+                       /* FIXME: We should run *parent* and run probe until
+                        * calls match up again. */
+                       probe_count = 3;
+                       break;
+               default:
+                       abort();
+               }
+       }
+
+       files = save_files();
+
        /* We're going to fail in the child. */
        call->fail = true;
        if (pipe(control) != 0 || pipe(output) != 0)
@@ -274,7 +431,7 @@ static bool should_fail(struct failtest_call *call)
        if (child == 0) {
                if (tracefd != -1) {
                        struct timeval now;
-                       char str[50], *p;
+                       const char *p;
                        gettimeofday(&now, NULL);
                        if (now.tv_usec < start.tv_usec) {
                                now.tv_sec--;
@@ -282,20 +439,16 @@ static bool should_fail(struct failtest_call *call)
                        }
                        now.tv_usec -= start.tv_usec;
                        now.tv_sec -= start.tv_sec;
-                       sprintf(str, "%u (%u.%02u): ", getpid(),
-                               (int)now.tv_sec, (int)now.tv_usec / 10000);
-                       trace_str(str);
                        p = failpath_string();
-                       trace_str(p);
-                       free(p);
-                       trace_str("(");
-                       p = strchr(history[history_num-1].file, '/');
+                       trace("%u->%u (%u.%02u): %s (", getppid(), getpid(),
+                             (int)now.tv_sec, (int)now.tv_usec / 10000, p);
+                       free((char *)p);
+                       p = strrchr(history[history_num-1].file, '/');
                        if (p)
-                               trace_str(p+1);
+                               trace("%s", p+1);
                        else
-                               trace_str(history[history_num-1].file);
-                       sprintf(str, ":%u)\n", history[history_num-1].line);
-                       trace_str(str);
+                               trace("%s", history[history_num-1].file);
+                       trace(":%u)\n", history[history_num-1].line);
                }
                close(control[0]);
                close(output[0]);
@@ -355,9 +508,13 @@ static bool should_fail(struct failtest_call *call)
        close(output[0]);
        close(control[0]);
        waitpid(child, &status, 0);
-       if (!WIFEXITED(status))
-               child_fail(out, outlen, "Killed by signal %u: ",
-                          WTERMSIG(status));
+       if (!WIFEXITED(status)) {
+               if (WTERMSIG(status) == SIGUSR1)
+                       child_fail(out, outlen, "Timed out");
+               else
+                       child_fail(out, outlen, "Killed by signal %u: ",
+                                  WTERMSIG(status));
+       }
        /* Child printed failure already, just pass up exit code. */
        if (type == FAILURE) {
                fprintf(stderr, "%.*s", (int)outlen, out);
@@ -371,6 +528,8 @@ static bool should_fail(struct failtest_call *call)
        free(out);
        signal(SIGUSR1, SIG_DFL);
 
+       restore_files(files);
+
        /* We continue onwards without failing. */
        call->fail = false;
        return false;
@@ -510,14 +669,18 @@ int failtest_open(const char *pathname,
        /* Avoid memory leak! */
        if (p == &unrecorded_call)
                free((char *)call.pathname);
-       if (should_fail(p)) {
+       p->u.open.ret = open(pathname, call.flags, call.mode);
+
+       if (!failpath && p->u.open.ret == -1) {
+               p->fail = false;
+               p->error = errno;
+       } else if (should_fail(p)) {
+               close(p->u.open.ret);
                p->u.open.ret = -1;
                /* FIXME: Play with error codes? */
                p->error = EACCES;
        } else {
-               p->u.open.ret = open(pathname, call.flags, call.mode);
                set_cleanup(p, cleanup_open, struct open_call);
-               p->u.open.dup_fd = p->u.open.ret;
        }
        errno = p->error;
        return p->u.open.ret;
@@ -552,11 +715,6 @@ int failtest_pipe(int pipefd[2], const char *file, unsigned line)
        return p->u.pipe.ret;
 }
 
-static void cleanup_read(struct read_call *call)
-{
-       lseek(call->fd, call->off, SEEK_SET);
-}
-
 ssize_t failtest_pread(int fd, void *buf, size_t count, off_t off,
                       const char *file, unsigned line)
 {
@@ -574,61 +732,26 @@ ssize_t failtest_pread(int fd, void *buf, size_t count, off_t off,
                p->error = EIO;
        } else {
                p->u.read.ret = pread(fd, buf, count, off);
-               set_cleanup(p, cleanup_read, struct read_call);
        }
        errno = p->error;
        return p->u.read.ret;
 }
 
-static void cleanup_write(struct write_call *call)
-{
-       lseek(call->dup_fd, call->off, SEEK_SET);
-       write(call->dup_fd, call->saved_contents, call->saved_len);
-       lseek(call->dup_fd, call->off, SEEK_SET);
-       ftruncate(call->dup_fd, call->old_filelen);
-       free(call->saved_contents);
-}
-
 ssize_t failtest_pwrite(int fd, const void *buf, size_t count, off_t off,
                        const char *file, unsigned line)
 {
        struct failtest_call *p;
        struct write_call call;
 
-       call.fd = call.dup_fd = fd;
+       call.fd = fd;
        call.buf = buf;
        call.count = count;
        call.off = off;
        p = add_history(FAILTEST_WRITE, file, line, &call);
 
-       /* Save old contents if we can */
-       if (p->u.write.off != -1) {
-               ssize_t ret;
-               p->u.write.old_filelen = lseek(fd, 0, SEEK_END);
-
-               /* Write past end of file?  Nothing to save.*/
-               if (p->u.write.old_filelen <= p->u.write.off)
-                       p->u.write.saved_len = 0;
-               /* Write which goes over end of file?  Partial save. */
-               else if (p->u.write.off + count > p->u.write.old_filelen)
-                       p->u.write.saved_len = p->u.write.old_filelen
-                               - p->u.write.off;
-               /* Full save. */
-               else
-                       p->u.write.saved_len = count;
-
-               p->u.write.saved_contents = malloc(p->u.write.saved_len);
-               lseek(fd, p->u.write.off, SEEK_SET);
-               ret = read(fd, p->u.write.saved_contents, p->u.write.saved_len);
-               if (ret != p->u.write.saved_len)
-                       err(1, "Expected %i bytes, got %i",
-                           (int)p->u.write.saved_len, (int)ret);
-               lseek(fd, p->u.write.off, SEEK_SET);
-               set_cleanup(p, cleanup_write, struct write_call);
-       }
-
-       /* If we're a child, tell parent about write. */
-       if (control_fd != -1) {
+       /* If we're a child, we need to make sure we write the same thing
+        * to non-files as the parent does, so tell it. */
+       if (control_fd != -1 && off == (off_t)-1) {
                enum info_type type = WRITE;
 
                write_all(control_fd, &type, sizeof(type));
@@ -642,7 +765,7 @@ ssize_t failtest_pwrite(int fd, const void *buf, size_t count, off_t off,
                p->error = EIO;
        } else {
                /* FIXME: We assume same write order in parent and child */
-               if (child_writes_num != 0) {
+               if (off == (off_t)-1 && child_writes_num != 0) {
                        if (child_writes[0].fd != fd)
                                errx(1, "Child wrote to fd %u, not %u?",
                                     child_writes[0].fd, fd);
@@ -754,49 +877,50 @@ add_lock(struct lock_info *locks, int fd, off_t start, off_t end, int type)
        return locks;
 }
 
-/* We only trap this so we can dup fds in case we need to restore. */
-int failtest_close(int fd)
+/* We trap this so we can record it: we don't fail it. */
+int failtest_close(int fd, const char *file, unsigned line)
 {
-       int new_fd = -1, i;
+       int i;
+       struct close_call call;
+       struct failtest_call *p;
+
+       call.fd = fd;
+       p = add_history(FAILTEST_CLOSE, file, line, &call);
+       p->fail = false;
+
+       /* Consume close from failpath. */
+       if (failpath)
+               if (should_fail(p))
+                       abort();
 
        if (fd < 0)
                return close(fd);
 
-       /* Trace history to find source of fd, and if we need to cleanup writes. */
+       /* Trace history to find source of fd. */
        for (i = history_num-1; i >= 0; i--) {
                switch (history[i].type) {
-               case FAILTEST_WRITE:
-                       if (history[i].u.write.fd != fd)
-                               break;
-                       if (!history[i].cleanup)
-                               break;
-                       /* We need to save fd so we can restore file. */
-                       if (new_fd == -1)
-                               new_fd = dup(fd);
-                       history[i].u.write.dup_fd = new_fd;
-                       break;
-               case FAILTEST_READ:
-                       /* We don't need to cleanup reads on closed fds. */
-                       if (history[i].u.read.fd != fd)
-                               break;
-                       history[i].cleanup = NULL;
-                       break;
                case FAILTEST_PIPE:
-                       /* From a pipe?  We don't ever restore pipes... */
+                       /* From a pipe? */
                        if (history[i].u.pipe.fds[0] == fd) {
-                               assert(new_fd == -1);
+                               assert(!history[i].u.pipe.closed[0]);
                                history[i].u.pipe.closed[0] = true;
+                               if (history[i].u.pipe.closed[1])
+                                       history[i].cleanup = NULL;
                                goto out;
                        }
                        if (history[i].u.pipe.fds[1] == fd) {
-                               assert(new_fd == -1);
+                               assert(!history[i].u.pipe.closed[1]);
                                history[i].u.pipe.closed[1] = true;
+                               if (history[i].u.pipe.closed[0])
+                                       history[i].cleanup = NULL;
                                goto out;
                        }
                        break;
                case FAILTEST_OPEN:
                        if (history[i].u.open.ret == fd) {
-                               history[i].u.open.dup_fd = new_fd;
+                               assert((void *)history[i].cleanup
+                                      == (void *)cleanup_open);
+                               history[i].cleanup = NULL;
                                goto out;
                        }
                        break;
@@ -857,7 +981,6 @@ int failtest_fcntl(int fd, const char *file, unsigned line, int cmd, ...)
        }
 
        p = add_history(FAILTEST_FCNTL, file, line, &call);
-       get_locks();
 
        if (should_fail(p)) {
                p->u.fcntl.ret = -1;
@@ -866,6 +989,7 @@ int failtest_fcntl(int fd, const char *file, unsigned line, int cmd, ...)
                else
                        p->error = EDEADLK;
        } else {
+               get_locks();
                p->u.fcntl.ret = fcntl(p->u.fcntl.fd, p->u.fcntl.cmd,
                                       &p->u.fcntl.arg.fl);
                if (p->u.fcntl.ret == -1)
@@ -895,44 +1019,20 @@ void failtest_init(int argc, char *argv[])
                } else if (strcmp(argv[i], "--tracepath") == 0) {
                        tracefd = dup(STDERR_FILENO);
                        failtest_timeout_ms = -1;
+               } else if (!strncmp(argv[i], "--debugpath=",
+                                   strlen("--debugpath="))) {
+                       debugpath = argv[i] + strlen("--debugpath=");
                }
        }
        gettimeofday(&start, NULL);
 }
 
-/* Free up memory, so valgrind doesn't report leaks. */
-static void free_everything(void)
-{
-       unsigned int i;
-
-       /* We don't do this in cleanup: needed even for failed opens. */
-       for (i = 0; i < history_num; i++) {
-               if (history[i].type == FAILTEST_OPEN)
-                       free((char *)history[i].u.open.pathname);
-       }
-       free(history);
-}
-
 void failtest_exit(int status)
 {
-       int i;
-
-       if (control_fd == -1) {
-               free_everything();
-               exit(status);
-       }
-
        if (failtest_exit_check) {
                if (!failtest_exit_check(history, history_num))
                        child_fail(NULL, 0, "failtest_exit_check failed\n");
        }
 
-       /* Cleanup everything, in reverse order. */
-       for (i = history_num - 1; i >= 0; i--)
-               if (history[i].cleanup)
-                       history[i].cleanup(&history[i].u);
-
-       free_everything();
-       tell_parent(SUCCESS);
-       exit(0);
+       failtest_cleanup(false, status);
 }