lib/tdb/test/run-mutex-transaction1.c

   1 #include "../common/tdb_private.h"
   2 #include "../common/io.c"
   3 #include "../common/tdb.c"
   4 #include "../common/lock.c"
   5 #include "../common/freelist.c"
   6 #include "../common/traverse.c"
   7 #include "../common/transaction.c"
   8 #include "../common/error.c"
   9 #include "../common/open.c"
  10 #include "../common/check.c"
  11 #include "../common/hash.c"
  12 #include "../common/mutex.c"
  13 #include "tap-interface.h"
  14 #include <stdlib.h>
  15 #include <sys/types.h>
  16 #include <sys/wait.h>
  17 #include <stdarg.h>
  18
  19 static TDB_DATA key, data;
  20
  21 static void log_fn(struct tdb_context *tdb, enum tdb_debug_level level,
  22                    const char *fmt, ...)
  23 {
  24         va_list ap;
  25         va_start(ap, fmt);
  26         vfprintf(stderr, fmt, ap);
  27         va_end(ap);
  28 }
  29
  30 static int do_child(int tdb_flags, int to, int from)
  31 {
  32         struct tdb_context *tdb;
  33         unsigned int log_count;
  34         struct tdb_logging_context log_ctx = { log_fn, &log_count };
  35         int ret;
  36         char c = 0;
  37
  38         tdb = tdb_open_ex("mutex-transaction1.tdb", 3, tdb_flags,
  39                           O_RDWR|O_CREAT, 0755, &log_ctx, NULL);
  40         ok(tdb, "tdb_open_ex should succeed");
  41
  42         ret = tdb_transaction_start(tdb);
  43         ok(ret == 0, "tdb_transaction_start should succeed");
  44
  45         ret = tdb_store(tdb, key, data, TDB_INSERT);
  46         ok(ret == 0, "tdb_store(tdb, key, data, TDB_INSERT) should succeed");
  47
  48         write(to, &c, sizeof(c));
  49         read(from, &c, sizeof(c));
  50
  51         ret = tdb_transaction_cancel(tdb);
  52         ok(ret == 0, "tdb_transaction_cancel should succeed");
  53
  54         write(to, &c, sizeof(c));
  55         read(from, &c, sizeof(c));
  56
  57         ret = tdb_transaction_start(tdb);
  58         ok(ret == 0, "tdb_transaction_start should succeed");
  59
  60         ret = tdb_store(tdb, key, data, TDB_INSERT);
  61         ok(ret == 0, "tdb_store(tdb, key, data, TDB_INSERT) should succeed");
  62
  63         write(to, &c, sizeof(c));
  64         read(from, &c, sizeof(c));
  65
  66         ret = tdb_transaction_commit(tdb);
  67         ok(ret == 0, "tdb_transaction_commit should succeed");
  68
  69         write(to, &c, sizeof(c));
  70         read(from, &c, sizeof(c));
  71
  72         ret = tdb_transaction_start(tdb);
  73         ok(ret == 0, "tdb_transaction_start should succeed");
  74
  75         ret = tdb_store(tdb, key, key, TDB_REPLACE);
  76         ok(ret == 0, "tdb_store(tdb, key, data, TDB_REPLACE) should succeed");
  77
  78         write(to, &c, sizeof(c));
  79         read(from, &c, sizeof(c));
  80
  81         ret = tdb_transaction_commit(tdb);
  82         ok(ret == 0, "tdb_transaction_commit should succeed");
  83
  84         write(to, &c, sizeof(c));
  85         read(from, &c, sizeof(c));
  86
  87         return 0;
  88 }
  89
  90 /* The code should barf on TDBs created with rwlocks. */
  91 int main(int argc, char *argv[])
  92 {
  93         struct tdb_context *tdb;
  94         unsigned int log_count;
  95         struct tdb_logging_context log_ctx = { log_fn, &log_count };
  96         int ret, status;
  97         pid_t child, wait_ret;
  98         int fromchild[2];
  99         int tochild[2];
 100         TDB_DATA val;
 101         char c;
 102         int tdb_flags;
 103         bool runtime_support;
 104
 105         runtime_support = tdb_runtime_check_for_robust_mutexes();
 106
 107         if (!runtime_support) {
 108                 skip(1, "No robust mutex support");
 109                 return exit_status();
 110         }
 111
 112         key.dsize = strlen("hi");
 113         key.dptr = discard_const_p(uint8_t, "hi");
 114         data.dsize = strlen("world");
 115         data.dptr = discard_const_p(uint8_t, "world");
 116
 117         pipe(fromchild);
 118         pipe(tochild);
 119
 120         tdb_flags = TDB_INCOMPATIBLE_HASH|
 121                 TDB_MUTEX_LOCKING|
 122                 TDB_CLEAR_IF_FIRST;
 123
 124         child = fork();
 125         if (child == 0) {
 126                 close(fromchild[0]);
 127                 close(tochild[1]);
 128                 return do_child(tdb_flags, fromchild[1], tochild[0]);
 129         }
 130         close(fromchild[1]);
 131         close(tochild[0]);
 132
 133         read(fromchild[0], &c, sizeof(c));
 134
 135         tdb = tdb_open_ex("mutex-transaction1.tdb", 0,
 136                           tdb_flags, O_RDWR|O_CREAT, 0755,
 137                           &log_ctx, NULL);
 138         ok(tdb, "tdb_open_ex should succeed");
 139
 140         /*
 141          * The child has the transaction running
 142          */
 143         ret = tdb_transaction_start_nonblock(tdb);
 144         ok(ret == -1, "tdb_transaction_start_nonblock not succeed");
 145
 146         ret = tdb_chainlock_nonblock(tdb, key);
 147         ok(ret == -1, "tdb_chainlock_nonblock should not succeed");
 148
 149         /*
 150          * We can still read
 151          */
 152         ret = tdb_exists(tdb, key);
 153         ok(ret == 0, "tdb_exists(tdb, key) should return 0");
 154
 155         val = tdb_fetch(tdb, key);
 156         ok(val.dsize == 0, "tdb_fetch(tdb, key) should return an empty value");
 157
 158         write(tochild[1], &c, sizeof(c));
 159
 160         /*
 161          * When the child canceled we can start...
 162          */
 163         ret = tdb_transaction_start(tdb);
 164         ok(ret == 0, "tdb_transaction_start should succeed");
 165
 166         read(fromchild[0], &c, sizeof(c));
 167         write(tochild[1], &c, sizeof(c));
 168
 169         ret = tdb_transaction_cancel(tdb);
 170         ok(ret == 0, "tdb_transaction_cancel should succeed");
 171
 172         /*
 173          * When we canceled the child can start and store...
 174          */
 175         read(fromchild[0], &c, sizeof(c));
 176
 177         /*
 178          * We still see the old values before the child commits...
 179          */
 180         ret = tdb_exists(tdb, key);
 181         ok(ret == 0, "tdb_exists(tdb, key) should return 0");
 182
 183         val = tdb_fetch(tdb, key);
 184         ok(val.dsize == 0, "tdb_fetch(tdb, key) should return an empty value");
 185
 186         write(tochild[1], &c, sizeof(c));
 187         read(fromchild[0], &c, sizeof(c));
 188
 189         /*
 190          * We see the new values after the commit...
 191          */
 192         ret = tdb_exists(tdb, key);
 193         ok(ret == 1, "tdb_exists(tdb, key) should return 1");
 194
 195         val = tdb_fetch(tdb, key);
 196         ok(val.dsize != 0, "tdb_fetch(tdb, key) should return a value");
 197         ok(val.dsize == data.dsize, "tdb_fetch(tdb, key) should return a value");
 198         ok(memcmp(val.dptr, data.dptr, data.dsize) == 0, "tdb_fetch(tdb, key) should return a value");
 199
 200         write(tochild[1], &c, sizeof(c));
 201         read(fromchild[0], &c, sizeof(c));
 202
 203         /*
 204          * The child started a new transaction and replaces the value,
 205          * but we still see the old values before the child commits...
 206          */
 207         ret = tdb_exists(tdb, key);
 208         ok(ret == 1, "tdb_exists(tdb, key) should return 1");
 209
 210         val = tdb_fetch(tdb, key);
 211         ok(val.dsize != 0, "tdb_fetch(tdb, key) should return a value");
 212         ok(val.dsize == data.dsize, "tdb_fetch(tdb, key) should return a value");
 213         ok(memcmp(val.dptr, data.dptr, data.dsize) == 0, "tdb_fetch(tdb, key) should return a value");
 214
 215         write(tochild[1], &c, sizeof(c));
 216         read(fromchild[0], &c, sizeof(c));
 217
 218         /*
 219          * We see the new values after the commit...
 220          */
 221         ret = tdb_exists(tdb, key);
 222         ok(ret == 1, "tdb_exists(tdb, key) should return 1");
 223
 224         val = tdb_fetch(tdb, key);
 225         ok(val.dsize != 0, "tdb_fetch(tdb, key) should return a value");
 226         ok(val.dsize == key.dsize, "tdb_fetch(tdb, key) should return a value");
 227         ok(memcmp(val.dptr, key.dptr, key.dsize) == 0, "tdb_fetch(tdb, key) should return a value");
 228
 229         write(tochild[1], &c, sizeof(c));
 230
 231         wait_ret = wait(&status);
 232         ok(wait_ret == child, "child should have exited correctly");
 233
 234         diag("done");
 235         return exit_status();
 236 }