failtest: don't use special data structure for storing child writes.
authorRusty Russell <rusty@rustcorp.com.au>
Tue, 15 Feb 2011 12:52:17 +0000 (23:22 +1030)
committerRusty Russell <rusty@rustcorp.com.au>
Tue, 15 Feb 2011 12:52:17 +0000 (23:22 +1030)
Use the same structure we use in the history.

ccan/failtest/failtest.c

index 09b92b601c6cb8f36c6b5f3a6b59a583cd66b7d8..2df1ae668e01e06318f535a2fa5f3a75466968cf 100644 (file)
@@ -34,17 +34,6 @@ enum info_type {
        UNEXPECTED
 };
 
-struct write_info_hdr {
-       size_t len;
-       off_t offset;
-       int fd;
-};
-
-struct write_info {
-       struct write_info_hdr hdr;
-       char *data;
-};
-
 struct lock_info {
        int fd;
        /* end is inclusive: you can't have a 0-byte lock. */
@@ -59,10 +48,7 @@ static unsigned int history_num = 0;
 static int control_fd = -1;
 static struct timeval start;
 
-static struct write_info *writes = NULL;
-static unsigned int writes_num = 0;
-
-static struct write_info *child_writes = NULL;
+static struct write_call *child_writes = NULL;
 static unsigned int child_writes_num = 0;
 
 static pid_t lock_owner;
@@ -106,16 +92,18 @@ bool failtest_default_hook(struct failtest_call *history, unsigned num)
 
 static bool read_write_info(int fd)
 {
-       struct write_info_hdr hdr;
-
-       if (!read_all(fd, &hdr, sizeof(hdr)))
-               return false;
+       struct write_call *w;
+       char *buf;
 
+       /* We don't need all of this, but it's simple. */
        child_writes = realloc(child_writes,
                               (child_writes_num+1) * sizeof(child_writes[0]));
-       child_writes[child_writes_num].hdr = hdr;
-       child_writes[child_writes_num].data = malloc(hdr.len);
-       if (!read_all(fd, child_writes[child_writes_num].data, hdr.len))
+       w = &child_writes[child_writes_num];
+       if (!read_all(fd, w, sizeof(*w)))
+               return false;
+
+       w->buf = buf = malloc(w->count);
+       if (!read_all(fd, buf, w->count))
                return false;
 
        child_writes_num++;
@@ -592,12 +580,6 @@ ssize_t failtest_pread(int fd, void *buf, size_t count, off_t off,
        return p->u.read.ret;
 }
 
-static struct write_info *new_write(void)
-{
-       writes = realloc(writes, (writes_num + 1) * sizeof(*writes));
-       return &writes[writes_num++];
-}
-
 static void cleanup_write(struct write_call *call)
 {
        lseek(call->dup_fd, call->off, SEEK_SET);
@@ -647,17 +629,11 @@ ssize_t failtest_pwrite(int fd, const void *buf, size_t count, off_t off,
 
        /* If we're a child, tell parent about write. */
        if (control_fd != -1) {
-               struct write_info *winfo = new_write();
                enum info_type type = WRITE;
 
-               winfo->hdr.len = count;
-               winfo->hdr.fd = fd;
-               winfo->data = malloc(count);
-               memcpy(winfo->data, buf, count);
-               winfo->hdr.offset = off;
                write_all(control_fd, &type, sizeof(type));
-               write_all(control_fd, &winfo->hdr, sizeof(winfo->hdr));
-               write_all(control_fd, winfo->data, count);
+               write_all(control_fd, &p->u.write, sizeof(p->u.write));
+               write_all(control_fd, buf, count);
        }
 
        /* FIXME: Try partial write returns. */
@@ -667,22 +643,22 @@ ssize_t failtest_pwrite(int fd, const void *buf, size_t count, off_t off,
        } else {
                /* FIXME: We assume same write order in parent and child */
                if (child_writes_num != 0) {
-                       if (child_writes[0].hdr.fd != fd)
+                       if (child_writes[0].fd != fd)
                                errx(1, "Child wrote to fd %u, not %u?",
-                                    child_writes[0].hdr.fd, fd);
-                       if (child_writes[0].hdr.offset != p->u.write.off)
+                                    child_writes[0].fd, fd);
+                       if (child_writes[0].off != p->u.write.off)
                                errx(1, "Child wrote to offset %zu, not %zu?",
-                                    (size_t)child_writes[0].hdr.offset,
+                                    (size_t)child_writes[0].off,
                                     (size_t)p->u.write.off);
-                       if (child_writes[0].hdr.len != count)
+                       if (child_writes[0].count != count)
                                errx(1, "Child wrote length %zu, not %zu?",
-                                    child_writes[0].hdr.len, count);
-                       if (memcmp(child_writes[0].data, buf, count)) {
+                                    child_writes[0].count, count);
+                       if (memcmp(child_writes[0].buf, buf, count)) {
                                child_fail(NULL, 0,
                                           "Child wrote differently to"
                                           " fd %u than we did!\n", fd);
                        }
-                       free(child_writes[0].data);
+                       free((char *)child_writes[0].buf);
                        child_writes_num--;
                        memmove(&child_writes[0], &child_writes[1],
                                sizeof(child_writes[0]) * child_writes_num);
@@ -929,11 +905,6 @@ static void free_everything(void)
 {
        unsigned int i;
 
-       for (i = 0; i < writes_num; i++) {
-               free(writes[i].data);
-       }
-       free(writes);
-
        /* 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)