lib/ntdb/test/api-82-lockattr.c

   1 #include "private.h" // for ntdb_fcntl_unlock
   2 #include "ntdb.h"
   3 #include "tap-interface.h"
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <fcntl.h>
   7 #include <errno.h>
   8 #include "logging.h"
   9
  10 static int mylock(int fd, int rw, off_t off, off_t len, bool waitflag,
  11                   void *_err)
  12 {
  13         int *lock_err = _err;
  14         struct flock fl;
  15         int ret;
  16
  17         if (*lock_err) {
  18                 errno = *lock_err;
  19                 return -1;
  20         }
  21
  22         do {
  23                 fl.l_type = rw;
  24                 fl.l_whence = SEEK_SET;
  25                 fl.l_start = off;
  26                 fl.l_len = len;
  27
  28                 if (waitflag)
  29                         ret = fcntl(fd, F_SETLKW, &fl);
  30                 else
  31                         ret = fcntl(fd, F_SETLK, &fl);
  32         } while (ret != 0 && errno == EINTR);
  33
  34         return ret;
  35 }
  36
  37 static int trav_err;
  38 static int trav(struct ntdb_context *ntdb, NTDB_DATA k, NTDB_DATA d, int *terr)
  39 {
  40         *terr = trav_err;
  41         return 0;
  42 }
  43
  44 int main(int argc, char *argv[])
  45 {
  46         unsigned int i;
  47         struct ntdb_context *ntdb;
  48         int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP,
  49                         NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT };
  50         union ntdb_attribute lock_attr;
  51         NTDB_DATA key = ntdb_mkdata("key", 3);
  52         NTDB_DATA data = ntdb_mkdata("data", 4);
  53         int lock_err;
  54
  55         lock_attr.base.attr = NTDB_ATTRIBUTE_FLOCK;
  56         lock_attr.base.next = &tap_log_attr;
  57         lock_attr.flock.lock = mylock;
  58         lock_attr.flock.unlock = ntdb_fcntl_unlock;
  59         lock_attr.flock.data = &lock_err;
  60
  61         plan_tests(sizeof(flags) / sizeof(flags[0]) * 80);
  62
  63         for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
  64                 NTDB_DATA d;
  65
  66                 /* Nonblocking open; expect no error message. */
  67                 lock_err = EAGAIN;
  68                 ntdb = ntdb_open("run-82-lockattr.ntdb", flags[i],
  69                                O_RDWR|O_CREAT|O_TRUNC, 0600, &lock_attr);
  70                 ok(errno == lock_err, "Errno is %u", errno);
  71                 ok1(!ntdb);
  72                 ok1(tap_log_messages == 0);
  73
  74                 lock_err = EINTR;
  75                 ntdb = ntdb_open("run-82-lockattr.ntdb", flags[i],
  76                                O_RDWR|O_CREAT|O_TRUNC, 0600, &lock_attr);
  77                 ok(errno == lock_err, "Errno is %u", errno);
  78                 ok1(!ntdb);
  79                 ok1(tap_log_messages == 0);
  80
  81                 /* Forced fail open. */
  82                 lock_err = ENOMEM;
  83                 ntdb = ntdb_open("run-82-lockattr.ntdb", flags[i],
  84                                O_RDWR|O_CREAT|O_TRUNC, 0600, &lock_attr);
  85                 ok1(errno == lock_err);
  86                 ok1(!ntdb);
  87                 ok1(tap_log_messages == 1);
  88                 tap_log_messages = 0;
  89
  90                 lock_err = 0;
  91                 ntdb = ntdb_open("run-82-lockattr.ntdb", flags[i],
  92                                O_RDWR|O_CREAT|O_TRUNC, 0600, &lock_attr);
  93                 if (!ok1(ntdb))
  94                         continue;
  95                 ok1(tap_log_messages == 0);
  96
  97                 /* Nonblocking store. */
  98                 lock_err = EAGAIN;
  99                 ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == NTDB_ERR_LOCK);
 100                 ok1(tap_log_messages == 0);
 101                 lock_err = EINTR;
 102                 ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == NTDB_ERR_LOCK);
 103                 ok1(tap_log_messages == 0);
 104                 lock_err = ENOMEM;
 105                 ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == NTDB_ERR_LOCK);
 106                 ok1(tap_log_messages == 1);
 107                 tap_log_messages = 0;
 108
 109                 /* Nonblocking fetch. */
 110                 lock_err = EAGAIN;
 111                 ok1(!ntdb_exists(ntdb, key));
 112                 ok1(tap_log_messages == 0);
 113                 lock_err = EINTR;
 114                 ok1(!ntdb_exists(ntdb, key));
 115                 ok1(tap_log_messages == 0);
 116                 lock_err = ENOMEM;
 117                 ok1(!ntdb_exists(ntdb, key));
 118                 ok1(tap_log_messages == 1);
 119                 tap_log_messages = 0;
 120
 121                 lock_err = EAGAIN;
 122                 ok1(ntdb_fetch(ntdb, key, &d) == NTDB_ERR_LOCK);
 123                 ok1(tap_log_messages == 0);
 124                 lock_err = EINTR;
 125                 ok1(ntdb_fetch(ntdb, key, &d) == NTDB_ERR_LOCK);
 126                 ok1(tap_log_messages == 0);
 127                 lock_err = ENOMEM;
 128                 ok1(ntdb_fetch(ntdb, key, &d) == NTDB_ERR_LOCK);
 129                 ok1(tap_log_messages == 1);
 130                 tap_log_messages = 0;
 131
 132                 /* Nonblocking delete. */
 133                 lock_err = EAGAIN;
 134                 ok1(ntdb_delete(ntdb, key) == NTDB_ERR_LOCK);
 135                 ok1(tap_log_messages == 0);
 136                 lock_err = EINTR;
 137                 ok1(ntdb_delete(ntdb, key) == NTDB_ERR_LOCK);
 138                 ok1(tap_log_messages == 0);
 139                 lock_err = ENOMEM;
 140                 ok1(ntdb_delete(ntdb, key) == NTDB_ERR_LOCK);
 141                 ok1(tap_log_messages == 1);
 142                 tap_log_messages = 0;
 143
 144                 /* Nonblocking locks. */
 145                 lock_err = EAGAIN;
 146                 ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_LOCK);
 147                 ok1(tap_log_messages == 0);
 148                 lock_err = EINTR;
 149                 ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_LOCK);
 150                 ok1(tap_log_messages == 0);
 151                 lock_err = ENOMEM;
 152                 ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_LOCK);
 153                 ok1(tap_log_messages == 1);
 154                 tap_log_messages = 0;
 155
 156                 lock_err = EAGAIN;
 157                 ok1(ntdb_chainlock_read(ntdb, key) == NTDB_ERR_LOCK);
 158                 ok1(tap_log_messages == 0);
 159                 lock_err = EINTR;
 160                 ok1(ntdb_chainlock_read(ntdb, key) == NTDB_ERR_LOCK);
 161                 ok1(tap_log_messages == 0);
 162                 lock_err = ENOMEM;
 163                 ok1(ntdb_chainlock_read(ntdb, key) == NTDB_ERR_LOCK);
 164                 ok1(tap_log_messages == 1);
 165                 tap_log_messages = 0;
 166
 167                 lock_err = EAGAIN;
 168                 ok1(ntdb_lockall(ntdb) == NTDB_ERR_LOCK);
 169                 ok1(tap_log_messages == 0);
 170                 lock_err = EINTR;
 171                 ok1(ntdb_lockall(ntdb) == NTDB_ERR_LOCK);
 172                 ok1(tap_log_messages == 0);
 173                 lock_err = ENOMEM;
 174                 ok1(ntdb_lockall(ntdb) == NTDB_ERR_LOCK);
 175                 /* This actually does divide and conquer. */
 176                 ok1(tap_log_messages > 0);
 177                 tap_log_messages = 0;
 178
 179                 lock_err = EAGAIN;
 180                 ok1(ntdb_lockall_read(ntdb) == NTDB_ERR_LOCK);
 181                 ok1(tap_log_messages == 0);
 182                 lock_err = EINTR;
 183                 ok1(ntdb_lockall_read(ntdb) == NTDB_ERR_LOCK);
 184                 ok1(tap_log_messages == 0);
 185                 lock_err = ENOMEM;
 186                 ok1(ntdb_lockall_read(ntdb) == NTDB_ERR_LOCK);
 187                 ok1(tap_log_messages > 0);
 188                 tap_log_messages = 0;
 189
 190                 /* Nonblocking traverse; go nonblock partway through. */
 191                 lock_err = 0;
 192                 ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == 0);
 193                 trav_err = EAGAIN;
 194                 ok1(ntdb_traverse(ntdb, trav, &lock_err) == NTDB_ERR_LOCK);
 195                 ok1(tap_log_messages == 0);
 196                 trav_err = EINTR;
 197                 lock_err = 0;
 198                 ok1(ntdb_traverse(ntdb, trav, &lock_err) == NTDB_ERR_LOCK);
 199                 ok1(tap_log_messages == 0);
 200                 trav_err = ENOMEM;
 201                 lock_err = 0;
 202                 ok1(ntdb_traverse(ntdb, trav, &lock_err) == NTDB_ERR_LOCK);
 203                 ok1(tap_log_messages == 1);
 204                 tap_log_messages = 0;
 205
 206                 /* Nonblocking transactions. */
 207                 lock_err = EAGAIN;
 208                 ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_LOCK);
 209                 ok1(tap_log_messages == 0);
 210                 lock_err = EINTR;
 211                 ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_LOCK);
 212                 ok1(tap_log_messages == 0);
 213                 lock_err = ENOMEM;
 214                 ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_LOCK);
 215                 ok1(tap_log_messages == 1);
 216                 tap_log_messages = 0;
 217
 218                 /* Nonblocking transaction prepare. */
 219                 lock_err = 0;
 220                 ok1(ntdb_transaction_start(ntdb) == 0);
 221                 ok1(ntdb_delete(ntdb, key) == 0);
 222
 223                 lock_err = EAGAIN;
 224                 ok1(ntdb_transaction_prepare_commit(ntdb) == NTDB_ERR_LOCK);
 225                 ok1(tap_log_messages == 0);
 226
 227                 lock_err = 0;
 228                 ok1(ntdb_transaction_prepare_commit(ntdb) == 0);
 229                 ok1(ntdb_transaction_commit(ntdb) == 0);
 230
 231                 /* And the transaction was committed, right? */
 232                 ok1(!ntdb_exists(ntdb, key));
 233                 ntdb_close(ntdb);
 234                 ok1(tap_log_messages == 0);
 235         }
 236         return exit_status();
 237 }