1 /* this tests tdb by doing lots of ops from several simultaneous
2 writers - that stresses the locking code.
3 */
4
5 #include "replace.h"
6 #include "system/time.h"
7 #include "system/wait.h"
main()8 #include "system/filesys.h"
9 #include "tdb.h"
10
11 #ifdef HAVE_GETOPT_H
12 #include <getopt.h>
13 #endif
14
15
16 #define REOPEN_PROB 30
17 #define DELETE_PROB 8
18 #define STORE_PROB 4
19 #define APPEND_PROB 6
20 #define TRANSACTION_PROB 10
21 #define TRANSACTION_PREPARE_PROB 2
22 #define LOCKSTORE_PROB 5
23 #define TRAVERSE_PROB 20
24 #define TRAVERSE_READ_PROB 20
25 #define CULL_PROB 100
26 #define KEYLEN 3
27 #define DATALEN 100
28
29 static struct tdb_context *db;
30 static int in_transaction;
31 static int error_count;
32 static int always_transaction = 0;
33 static int hash_size = 2;
34 static unsigned loopnum;
35 static int count_pipe;
36 static bool mutex = false;
37 static struct tdb_logging_context log_ctx;
38
39 #ifdef PRINTF_ATTRIBUTE
40 static void tdb_log(struct tdb_context *tdb, enum tdb_debug_level level, const char *format, ...) PRINTF_ATTRIBUTE(3,4);
41 #endif
42 static void tdb_log(struct tdb_context *tdb, enum tdb_debug_level level, const char *format, ...)
43 {
44 va_list ap;
45
46 /* trace level messages do not indicate an error */
47 if (level != TDB_DEBUG_TRACE) {
48 error_count++;
49 }
50
51 va_start(ap, format);
52 vfprintf(stdout, format, ap);
53 va_end(ap);
54 fflush(stdout);
55 #if 0
56 if (level != TDB_DEBUG_TRACE) {
57 char *ptr;
58 signal(SIGUSR1, SIG_IGN);
59 asprintf(&ptr,"xterm -e gdb /proc/%d/exe %d", getpid(), getpid());
60 system(ptr);
61 free(ptr);
62 }
63 #endif
64 }
65
66 static void fatal(const char *why)
67 {
68 perror(why);
69 error_count++;
70 }
71
72 static char *randbuf(int len)
73 {
74 char *buf;
75 int i;
76 buf = (char *)malloc(len+1);
77
78 for (i=0;i<len;i++) {
79 buf[i] = 'a' + (rand() % 26);
80 }
81 buf[i] = 0;
82 return buf;
83 }
84
85 static int cull_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
86 void *state)
87 {
88 #if CULL_PROB
89 if (random() % CULL_PROB == 0) {
90 tdb_delete(tdb, key);
91 }
92 #endif
93 return 0;
94 }
95
96 static bool do_transaction(void)
97 {
98 #if TRANSACTION_PROB
99 if (mutex) {
100 return false;
101 }
102 if (random() % TRANSACTION_PROB == 0) {
103 return true;
104 }
105 #endif
106 return false;
107 }
108
109 static void addrec_db(void)
110 {
111 int klen, dlen;
112 char *k, *d;
113 TDB_DATA key, data;
114
115 klen = 1 + (rand() % KEYLEN);
116 dlen = 1 + (rand() % DATALEN);
117
118 k = randbuf(klen);
119 d = randbuf(dlen);
120
121 key.dptr = (unsigned char *)k;
122 key.dsize = klen+1;
123
124 data.dptr = (unsigned char *)d;
125 data.dsize = dlen+1;
126
127 #if REOPEN_PROB
128 if (in_transaction == 0 && random() % REOPEN_PROB == 0) {
129 tdb_reopen_all(0);
130 goto next;
131 }
132 #endif
133
134 if (in_transaction == 0 &&
135 (always_transaction || do_transaction())) {
136 if (tdb_transaction_start(db) != 0) {
137 fatal("tdb_transaction_start failed");
138 }
139 in_transaction++;
140 goto next;
141 }
142 if (in_transaction && do_transaction()) {
143 if (random() % TRANSACTION_PREPARE_PROB == 0) {
144 if (tdb_transaction_prepare_commit(db) != 0) {
145 fatal("tdb_transaction_prepare_commit failed");
146 }
147 }
148 if (tdb_transaction_commit(db) != 0) {
149 fatal("tdb_transaction_commit failed");
150 }
151 in_transaction--;
152 goto next;
153 }
154 if (in_transaction && do_transaction()) {
155 if (tdb_transaction_cancel(db) != 0) {
156 fatal("tdb_transaction_cancel failed");
157 }
158 in_transaction--;
159 goto next;
160 }
161
162 #if DELETE_PROB
163 if (random() % DELETE_PROB == 0) {
164 tdb_delete(db, key);
165 goto next;
166 }
167 #endif
168
169 #if STORE_PROB
170 if (random() % STORE_PROB == 0) {
171 if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
172 fatal("tdb_store failed");
173 }
174 goto next;
175 }
176 #endif
177
178 #if APPEND_PROB
179 if (random() % APPEND_PROB == 0) {
180 if (tdb_append(db, key, data) != 0) {
181 fatal("tdb_append failed");
182 }
183 goto next;
184 }
185 #endif
186
187 #if LOCKSTORE_PROB
188 if (random() % LOCKSTORE_PROB == 0) {
189 tdb_chainlock(db, key);
190 data = tdb_fetch(db, key);
191 if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
192 fatal("tdb_store failed");
193 }
194 if (data.dptr) free(data.dptr);
195 tdb_chainunlock(db, key);
196 goto next;
197 }
198 #endif
199
200 #if TRAVERSE_PROB
201 if (random() % TRAVERSE_PROB == 0) {
202 tdb_traverse(db, cull_traverse, NULL);
203 goto next;
204 }
205 #endif
206
207 #if TRAVERSE_READ_PROB
208 if (random() % TRAVERSE_READ_PROB == 0) {
209 tdb_traverse_read(db, NULL, NULL);
210 goto next;
211 }
212 #endif
213
214 data = tdb_fetch(db, key);
215 if (data.dptr) free(data.dptr);
216
217 next:
218 free(k);
219 free(d);
220 }
221
222 static int traverse_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
223 void *state)
224 {
225 tdb_delete(tdb, key);
226 return 0;
227 }
228
229 static void usage(void)
230 {
231 printf("Usage: tdbtorture [-t] [-k] [-m] [-n NUM_PROCS] [-l NUM_LOOPS] [-s SEED] [-H HASH_SIZE]\n");
232 exit(0);
233 }
234
235 static void send_count_and_suicide(int sig)
236 {
237 ssize_t ret;
238
239 /* This ensures our successor can continue where we left off. */
240 do {
241 ret = write(count_pipe, &loopnum, sizeof(loopnum));
242 } while (ret == -1 && errno == EINTR);
243 /* This gives a unique signature. */
244 kill(getpid(), SIGUSR2);
245 }
246
247 static int run_child(const char *filename, int i, int seed, unsigned num_loops, unsigned start)
248 {
249 int tdb_flags = TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH;
250
251 if (mutex) {
252 tdb_flags |= TDB_MUTEX_LOCKING;
253 }
254
255 db = tdb_open_ex(filename, hash_size, tdb_flags,
256 O_RDWR | O_CREAT, 0600, &log_ctx, NULL);
257 if (!db) {
258 fatal("db open failed");
259 }
260
261 srand(seed + i);
262 srandom(seed + i);
263
264 /* Set global, then we're ready to handle being killed. */
265 loopnum = start;
266 signal(SIGUSR1, send_count_and_suicide);
267
268 for (;loopnum<num_loops && error_count == 0;loopnum++) {
269 addrec_db();
270 }
271
272 if (error_count == 0) {
273 tdb_traverse_read(db, NULL, NULL);
274 if (always_transaction) {
275 while (in_transaction) {
276 tdb_transaction_cancel(db);
277 in_transaction--;
278 }
279 if (tdb_transaction_start(db) != 0)
280 fatal("tdb_transaction_start failed");
281 }
282 tdb_traverse(db, traverse_fn, NULL);
283 tdb_traverse(db, traverse_fn, NULL);
284 if (always_transaction) {
285 if (tdb_transaction_commit(db) != 0)
286 fatal("tdb_transaction_commit failed");
287 }
288 }
289
290 tdb_close(db);
291
292 return (error_count < 100 ? error_count : 100);
293 }
294
295 static char *test_path(const char *filename)
296 {
297 const char *prefix = getenv("TEST_DATA_PREFIX");
298
299 if (prefix) {
300 char *path = NULL;
301 int ret;
302
303 ret = asprintf(&path, "%s/%s", prefix, filename);
304 if (ret == -1) {
305 return NULL;
306 }
307 return path;
308 }
309
310 return strdup(filename);
311 }
312
313 int main(int argc, char * const *argv)
314 {
315 int i, seed = -1;
316 int num_loops = 5000;
317 int num_procs = 3;
318 int c, pfds[2];
319 extern char *optarg;
320 pid_t *pids;
321 int kill_random = 0;
322 int *done;
323 char *test_tdb;
324
325 log_ctx.log_fn = tdb_log;
326
327 while ((c = getopt(argc, argv, "n:l:s:H:thkm")) != -1) {
328 switch (c) {
329 case 'n':
330 num_procs = strtol(optarg, NULL, 0);
331 break;
332 case 'l':
333 num_loops = strtol(optarg, NULL, 0);
334 break;
335 case 'H':
336 hash_size = strtol(optarg, NULL, 0);
337 break;
338 case 's':
339 seed = strtol(optarg, NULL, 0);
340 break;
341 case 't':
342 always_transaction = 1;
343 break;
344 case 'k':
345 kill_random = 1;
346 break;
347 case 'm':
348 mutex = tdb_runtime_check_for_robust_mutexes();
349 if (!mutex) {
350 printf("tdb_runtime_check_for_robust_mutexes() returned false\n");
351 exit(1);
352 }
353 break;
354 default:
355 usage();
356 }
357 }
358
359 test_tdb = test_path("torture.tdb");
360
361 unlink(test_tdb);
362
363 if (seed == -1) {
364 seed = (getpid() + time(NULL)) & 0x7FFFFFFF;
365 }
366
367 printf("Testing with %d processes, %d loops, %d hash_size, seed=%d%s\n",
368 num_procs, num_loops, hash_size, seed,
369 (always_transaction ? " (all within transactions)" : ""));
370
371 if (num_procs == 1 && !kill_random) {
372 /* Don't fork for this case, makes debugging easier. */
373 error_count = run_child(test_tdb, 0, seed, num_loops, 0);
374 goto done;
375 }
376
377 pids = (pid_t *)calloc(sizeof(pid_t), num_procs);
378 if (pids == NULL) {
379 perror("Unable to allocate memory for pids");
380 exit(1);
381 }
382 done = (int *)calloc(sizeof(int), num_procs);
383 if (done == NULL) {
384 perror("Unable to allocate memory for done");
385 exit(1);
386 }
387
388 if (pipe(pfds) != 0) {
389 perror("Creating pipe");
390 exit(1);
391 }
392 count_pipe = pfds[1];
393
394 for (i=0;i<num_procs;i++) {
395 if ((pids[i]=fork()) == 0) {
396 close(pfds[0]);
397 exit(run_child(test_tdb, i, seed, num_loops, 0));
398 }
399 }
400
401 while (num_procs) {
402 int status, j;
403 pid_t pid;
404
405 if (error_count != 0) {
406 /* try and stop the test on any failure */
407 for (j=0;j<num_procs;j++) {
408 if (pids[j] != 0) {
409 kill(pids[j], SIGTERM);
410 }
411 }
412 }
413
414 pid = waitpid(-1, &status, kill_random ? WNOHANG : 0);
415 if (pid == 0) {
416 struct timeval tv;
417
418 /* Sleep for 1/10 second. */
419 tv.tv_sec = 0;
420 tv.tv_usec = 100000;
421 select(0, NULL, NULL, NULL, &tv);
422
423 /* Kill someone. */
424 kill(pids[random() % num_procs], SIGUSR1);
425 continue;
426 }
427
428 if (pid == -1) {
429 perror("failed to wait for child\n");
430 exit(1);
431 }
432
433 for (j=0;j<num_procs;j++) {
434 if (pids[j] == pid) break;
435 }
436 if (j == num_procs) {
437 printf("unknown child %d exited!?\n", (int)pid);
438 exit(1);
439 }
440 if (WIFSIGNALED(status)) {
441 if (WTERMSIG(status) == SIGUSR2
442 || WTERMSIG(status) == SIGUSR1) {
443 /* SIGUSR2 means they wrote to pipe. */
444 if (WTERMSIG(status) == SIGUSR2) {
445 ssize_t ret;
446
447 do {
448 ret = read(pfds[0], &done[j],
449 sizeof(done[j]));
450 } while (ret == -1 && errno == EINTR);
451 }
452 pids[j] = fork();
453 if (pids[j] == 0)
454 exit(run_child(test_tdb, j, seed,
455 num_loops, done[j]));
456 printf("Restarting child %i for %u-%u\n",
457 j, done[j], num_loops);
458 continue;
459 }
460 printf("child %d exited with signal %d\n",
461 (int)pid, WTERMSIG(status));
462 error_count++;
463 } else {
464 if (WEXITSTATUS(status) != 0) {
465 printf("child %d exited with status %d\n",
466 (int)pid, WEXITSTATUS(status));
467 error_count++;
468 }
469 }
470 memmove(&pids[j], &pids[j+1],
471 (num_procs - j - 1)*sizeof(pids[0]));
472 num_procs--;
473 }
474
475 free(pids);
476
477 done:
478 if (error_count == 0) {
479 int tdb_flags = TDB_DEFAULT;
480
481 if (mutex) {
482 tdb_flags |= TDB_NOLOCK;
483 }
484
485 db = tdb_open_ex(test_tdb, hash_size, tdb_flags,
486 O_RDWR, 0, &log_ctx, NULL);
487 if (!db) {
488 fatal("db open failed\n");
489 exit(1);
490 }
491 if (tdb_check(db, NULL, NULL) == -1) {
492 printf("db check failed\n");
493 exit(1);
494 }
495 tdb_close(db);
496 printf("OK\n");
497 }
498
499 free(test_tdb);
500 return error_count;
501 }
502