Changeset 745 for trunk/server/lib/tdb/tools

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• lib/tdb/tools/tdbbackup.c (modified) (2 diffs)
• lib/tdb/tools/tdbrestore.c (copied) (copied from vendor/current/lib/tdb/tools/tdbrestore.c )
• lib/tdb/tools/tdbtest.c (modified) (3 diffs)
• lib/tdb/tools/tdbtool.c (modified) (2 diffs)
• lib/tdb/tools/tdbtorture.c (modified) (7 diffs)

trunk/server/lib/tdb/tools/tdbbackup.c

@@ -153 +153 @@
         }
 
-        if (tdb_transaction_start(tdb_new) != 0) {
-                printf("Failed to start transaction on new tdb\n");
+        /* lock the backup tdb so that nobody else can change it */
+        if (tdb_lockall(tdb_new) != 0) {
+                printf("Failed to lock backup tdb\n");
                 tdb_close(tdb);
                 tdb_close(tdb_new);
@@ -178 +179 @@
         tdb_close(tdb);
 
-        if (tdb_transaction_commit(tdb_new) != 0) {
-                fprintf(stderr, "Failed to commit new tdb\n");
-                tdb_close(tdb_new);
-                unlink(tmp_name);
-                free(tmp_name);         
-                return 1;
+        /* copy done, unlock the backup tdb */
+        tdb_unlockall(tdb_new);
+
+#ifdef HAVE_FDATASYNC
+        if (fdatasync(tdb_fd(tdb_new)) != 0) {
+#else
+        if (fsync(tdb_fd(tdb_new)) != 0) {
+#endif
+                /* not fatal */
+                fprintf(stderr, "failed to fsync backup file\n");
         }
 

trunk/server/lib/tdb/tools/tdbtest.c

@@ -216 +216 @@
 }
 
+static char *test_path(const char *filename)
+{
+        const char *prefix = getenv("TEST_DATA_PREFIX");
+
+        if (prefix) {
+                char *path = NULL;
+                int ret;
+
+                ret = asprintf(&path, "%s/%s", prefix, filename);
+                if (ret == -1) {
+                        return NULL;
+                }
+                return path;
+        }
+
+        return strdup(filename);
+}
+
  int main(int argc, const char *argv[])
 {
@@ -221 +239 @@
         int loops = 10000;
         int num_entries;
-        char test_gdbm[] = "test.gdbm";
-
-        unlink("test.gdbm");
-
-        db = tdb_open("test.tdb", 0, TDB_CLEAR_IF_FIRST, 
+        char test_gdbm[1] = "test.gdbm";
+        char *test_tdb;
+
+        test_gdbm[0] = test_path("test.gdbm");
+        test_tdb = test_path("test.tdb");
+
+        unlink(test_gdbm[0]);
+
+        db = tdb_open(test_tdb, 0, TDB_CLEAR_IF_FIRST,
                       O_RDWR | O_CREAT | O_TRUNC, 0600);
         gdbm = gdbm_open(test_gdbm, 512, GDBM_WRITER|GDBM_NEWDB|GDBM_FAST, 
@@ -262 +284 @@
         gdbm_close(gdbm);
 
+        free(test_gdbm[0]);
+        free(test_tdb);
+
         return 0;
 }

trunk/server/lib/tdb/tools/tdbtool.c

@@ -418 +418 @@
 static void info_tdb(void)
 {
-        int count;
-        total_bytes = 0;
-        if ((count = tdb_traverse(tdb, traverse_fn, NULL)) == -1)
+        char *summary = tdb_summary(tdb);
+
+        if (!summary) {
                 printf("Error = %s\n", tdb_errorstr(tdb));
-        else
-                printf("%d records totalling %d bytes\n", count, total_bytes);
+        } else {
+                printf("%s", summary);
+                free(summary);
+        }
 }
 
@@ -574 +576 @@
     if (cmdname) {
 #endif
-
         if (cmdname && strlen(cmdname) == 0) {
                 mycmd = CMD_NEXT;

trunk/server/lib/tdb/tools/tdbtorture.c

@@ -31 +31 @@
 static int error_count;
 static int always_transaction = 0;
+static int hash_size = 2;
+static int loopnum;
+static int count_pipe;
+static struct tdb_logging_context log_ctx;
 
 #ifdef PRINTF_ATTRIBUTE
@@ -49 +53 @@
         fflush(stdout);
 #if 0
-        {
+        if (level != TDB_DEBUG_TRACE) {
                 char *ptr;
+                signal(SIGUSR1, SIG_IGN);
                 asprintf(&ptr,"xterm -e gdb /proc/%d/exe %d", getpid(), getpid());
                 system(ptr);
@@ -212 +217 @@
 static void usage(void)
 {
-        printf("Usage: tdbtorture [-t] [-n NUM_PROCS] [-l NUM_LOOPS] [-s SEED] [-H HASH_SIZE]\n");
+        printf("Usage: tdbtorture [-t] [-k] [-n NUM_PROCS] [-l NUM_LOOPS] [-s SEED] [-H HASH_SIZE]\n");
         exit(0);
 }
 
- int main(int argc, char * const *argv)
-{
-        int i, seed = -1;
-        int num_procs = 3;
-        int num_loops = 5000;
-        int hash_size = 2;
-        int c;
-        extern char *optarg;
-        pid_t *pids;
-
-        struct tdb_logging_context log_ctx;
-        log_ctx.log_fn = tdb_log;
-
-        while ((c = getopt(argc, argv, "n:l:s:H:th")) != -1) {
-                switch (c) {
-                case 'n':
-                        num_procs = strtol(optarg, NULL, 0);
-                        break;
-                case 'l':
-                        num_loops = strtol(optarg, NULL, 0);
-                        break;
-                case 'H':
-                        hash_size = strtol(optarg, NULL, 0);
-                        break;
-                case 's':
-                        seed = strtol(optarg, NULL, 0);
-                        break;
-                case 't':
-                        always_transaction = 1;
-                        break;
-                default:
-                        usage();
-                }
-        }
-
-        unlink("torture.tdb");
-
-        pids = (pid_t *)calloc(sizeof(pid_t), num_procs);
-        pids[0] = getpid();
-
-        for (i=0;i<num_procs-1;i++) {
-                if ((pids[i+1]=fork()) == 0) break;
-        }
-
-        db = tdb_open_ex("torture.tdb", hash_size, TDB_CLEAR_IF_FIRST, 
+static void send_count_and_suicide(int sig)
+{
+        /* This ensures our successor can continue where we left off. */
+        write(count_pipe, &loopnum, sizeof(loopnum));
+        /* This gives a unique signature. */
+        kill(getpid(), SIGUSR2);
+}
+
+static int run_child(const char *filename, int i, int seed, unsigned num_loops, unsigned start)
+{
+        db = tdb_open_ex(filename, hash_size, TDB_DEFAULT,
                          O_RDWR | O_CREAT, 0600, &log_ctx, NULL);
         if (!db) {
@@ -266 +237 @@
         }
 
-        if (seed == -1) {
-                seed = (getpid() + time(NULL)) & 0x7FFFFFFF;
-        }
-
-        if (i == 0) {
-                printf("testing with %d processes, %d loops, %d hash_size, seed=%d%s\n",
-                       num_procs, num_loops, hash_size, seed, always_transaction ? " (all within transactions)" : "");
-        }
-
         srand(seed + i);
         srandom(seed + i);
 
-        for (i=0;i<num_loops && error_count == 0;i++) {
+        /* Set global, then we're ready to handle being killed. */
+        loopnum = start;
+        signal(SIGUSR1, send_count_and_suicide);
+
+        for (;loopnum<num_loops && error_count == 0;loopnum++) {
                 addrec_db();
         }
@@ -302 +268 @@
         tdb_close(db);
 
-        if (getpid() != pids[0]) {
-                return error_count;
-        }
-
-        for (i=1;i<num_procs;i++) {
+        return (error_count < 100 ? error_count : 100);
+}
+
+static char *test_path(const char *filename)
+{
+        const char *prefix = getenv("TEST_DATA_PREFIX");
+
+        if (prefix) {
+                char *path = NULL;
+                int ret;
+
+                ret = asprintf(&path, "%s/%s", prefix, filename);
+                if (ret == -1) {
+                        return NULL;
+                }
+                return path;
+        }
+
+        return strdup(filename);
+}
+
+int main(int argc, char * const *argv)
+{
+        int i, seed = -1;
+        int num_loops = 5000;
+        int num_procs = 3;
+        int c, pfds[2];
+        extern char *optarg;
+        pid_t *pids;
+        int kill_random = 0;
+        int *done;
+        char *test_tdb;
+
+        log_ctx.log_fn = tdb_log;
+
+        while ((c = getopt(argc, argv, "n:l:s:H:thk")) != -1) {
+                switch (c) {
+                case 'n':
+                        num_procs = strtol(optarg, NULL, 0);
+                        break;
+                case 'l':
+                        num_loops = strtol(optarg, NULL, 0);
+                        break;
+                case 'H':
+                        hash_size = strtol(optarg, NULL, 0);
+                        break;
+                case 's':
+                        seed = strtol(optarg, NULL, 0);
+                        break;
+                case 't':
+                        always_transaction = 1;
+                        break;
+                case 'k':
+                        kill_random = 1;
+                        break;
+                default:
+                        usage();
+                }
+        }
+
+        test_tdb = test_path("torture.tdb");
+
+        unlink(test_tdb);
+
+        if (seed == -1) {
+                seed = (getpid() + time(NULL)) & 0x7FFFFFFF;
+        }
+
+        if (num_procs == 1 && !kill_random) {
+                /* Don't fork for this case, makes debugging easier. */
+                error_count = run_child(test_tdb, 0, seed, num_loops, 0);
+                goto done;
+        }
+
+        pids = (pid_t *)calloc(sizeof(pid_t), num_procs);
+        done = (int *)calloc(sizeof(int), num_procs);
+
+        if (pipe(pfds) != 0) {
+                perror("Creating pipe");
+                exit(1);
+        }
+        count_pipe = pfds[1];
+
+        for (i=0;i<num_procs;i++) {
+                if ((pids[i]=fork()) == 0) {
+                        close(pfds[0]);
+                        if (i == 0) {
+                                printf("Testing with %d processes, %d loops, %d hash_size, seed=%d%s\n",
+                                       num_procs, num_loops, hash_size, seed, always_transaction ? " (all within transactions)" : "");
+                        }
+                        exit(run_child(test_tdb, i, seed, num_loops, 0));
+                }
+        }
+
+        while (num_procs) {
                 int status, j;
                 pid_t pid;
+
                 if (error_count != 0) {
                         /* try and stop the test on any failure */
-                        for (j=1;j<num_procs;j++) {
+                        for (j=0;j<num_procs;j++) {
                                 if (pids[j] != 0) {
                                         kill(pids[j], SIGTERM);
@@ -317 +374 @@
                         }
                 }
-                pid = waitpid(-1, &status, 0);
+
+                pid = waitpid(-1, &status, kill_random ? WNOHANG : 0);
+                if (pid == 0) {
+                        struct timeval tv;
+
+                        /* Sleep for 1/10 second. */
+                        tv.tv_sec = 0;
+                        tv.tv_usec = 100000;
+                        select(0, NULL, NULL, NULL, &tv);
+
+                        /* Kill someone. */
+                        kill(pids[random() % num_procs], SIGUSR1);
+                        continue;
+                }
+
                 if (pid == -1) {
                         perror("failed to wait for child\n");
                         exit(1);
                 }
-                for (j=1;j<num_procs;j++) {
+
+                for (j=0;j<num_procs;j++) {
                         if (pids[j] == pid) break;
                 }
@@ -329 +401 @@
                         exit(1);
                 }
-                if (WEXITSTATUS(status) != 0) {
-                        printf("child %d exited with status %d\n",
-                               (int)pid, WEXITSTATUS(status));
+                if (WIFSIGNALED(status)) {
+                        if (WTERMSIG(status) == SIGUSR2
+                            || WTERMSIG(status) == SIGUSR1) {
+                                /* SIGUSR2 means they wrote to pipe. */
+                                if (WTERMSIG(status) == SIGUSR2) {
+                                        read(pfds[0], &done[j],
+                                             sizeof(done[j]));
+                                }
+                                pids[j] = fork();
+                                if (pids[j] == 0)
+                                        exit(run_child(test_tdb, j, seed,
+                                                       num_loops, done[j]));
+                                printf("Restarting child %i for %u-%u\n",
+                                       j, done[j], num_loops);
+                                continue;
+                        }
+                        printf("child %d exited with signal %d\n",
+                               (int)pid, WTERMSIG(status));
                         error_count++;
-                }
-                pids[j] = 0;
+                } else {
+                        if (WEXITSTATUS(status) != 0) {
+                                printf("child %d exited with status %d\n",
+                                       (int)pid, WEXITSTATUS(status));
+                                error_count++;
+                        }
+                }
+                memmove(&pids[j], &pids[j+1],
+                        (num_procs - j - 1)*sizeof(pids[0]));
+                num_procs--;
         }
 
         free(pids);
 
+done:
         if (error_count == 0) {
+                db = tdb_open_ex(test_tdb, hash_size, TDB_DEFAULT,
+                                 O_RDWR, 0, &log_ctx, NULL);
+                if (!db) {
+                        fatal("db open failed");
+                }
+                if (tdb_check(db, NULL, NULL) == -1) {
+                        printf("db check failed");
+                        exit(1);
+                }
+                tdb_close(db);
                 printf("OK\n");
         }
 
+        free(test_tdb);
         return error_count;
 }