tests/test-lockfile.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "lockfile.h"
  20
  21 #include <errno.h>
  22 #include <stdlib.h>
  23 #include <sys/stat.h>
  24 #include <sys/wait.h>
  25 #include <unistd.h>
  26
  27 #include "process.h"
  28 #include "timeval.h"
  29 #include "util.h"
  30 #include "vlog.h"
  31
  32 struct test {
  33     const char *name;
  34     void (*function)(void);
  35 };
  36
  37 static const struct test tests[];
  38
  39 #define CHECK(A, B) check(A, B, #A, #B, __FILE__, __LINE__)
  40 static void
  41 check(int a, int b,
  42       const char *a_string, const char *b_string, const char *file, int line)
  43 {
  44     if (a != b) {
  45         fprintf(stderr, "%s:%d: expected %s == %s but %d != %d\n",
  46                 file, line, a_string, b_string, a, b);
  47         fflush(stderr);
  48         abort();
  49     }
  50 }
  51
  52 static void
  53 run_lock_and_unlock(void)
  54 {
  55     struct lockfile *lockfile;
  56
  57     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  58     lockfile_unlock(lockfile);
  59 }
  60
  61 static void
  62 run_lock_and_unlock_twice(void)
  63 {
  64     struct lockfile *lockfile;
  65
  66     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  67     lockfile_unlock(lockfile);
  68
  69     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  70     lockfile_unlock(lockfile);
  71 }
  72
  73 static void
  74 run_lock_blocks_same_process(void)
  75 {
  76     struct lockfile *lockfile;
  77
  78     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  79     CHECK(lockfile_lock("file", 0, &lockfile), EDEADLK);
  80     lockfile_unlock(lockfile);
  81 }
  82
  83 static void
  84 run_lock_blocks_same_process_twice(void)
  85 {
  86     struct lockfile *lockfile;
  87
  88     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  89     CHECK(lockfile_lock("file", 0, &lockfile), EDEADLK);
  90     CHECK(lockfile_lock("file", 0, &lockfile), EDEADLK);
  91     lockfile_unlock(lockfile);
  92 }
  93
  94 static enum { PARENT, CHILD }
  95 do_fork(void)
  96 {
  97     switch (fork()) {
  98     case 0:
  99         time_postfork();
 100         lockfile_postfork();
 101         return CHILD;
 102
 103     default:
 104         return PARENT;
 105
 106     case -1:
 107         /* Error. */
 108         ovs_fatal(errno, "fork failed");
 109     }
 110 }
 111
 112 static void
 113 run_lock_blocks_other_process(void)
 114 {
 115     /* Making this static prevents a memory leak warning from valgrind for the
 116      * parent process, which cannot easily unlock (and free) 'lockfile' because
 117      * it can only do so after the child has exited, and it's the caller of
 118      * this function that does the wait() call. */
 119     static struct lockfile *lockfile;
 120
 121     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 122     if (do_fork() == CHILD) {
 123         lockfile_unlock(lockfile);
 124         CHECK(lockfile_lock("file", 0, &lockfile), EAGAIN);
 125         exit(11);
 126     }
 127 }
 128
 129 static void
 130 run_lock_twice_blocks_other_process(void)
 131 {
 132     struct lockfile *lockfile, *dummy;
 133
 134     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 135     CHECK(lockfile_lock("file", 0, &dummy), EDEADLK);
 136     if (do_fork() == CHILD) {
 137         CHECK(lockfile_lock("file", 0, &dummy), EAGAIN);
 138         exit(11);
 139     }
 140 }
 141
 142 static void
 143 run_lock_and_unlock_allows_other_process(void)
 144 {
 145     struct lockfile *lockfile;
 146
 147     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 148     lockfile_unlock(lockfile);
 149
 150     if (do_fork() == CHILD) {
 151         CHECK(lockfile_lock("file", 0, &lockfile), 0);
 152         exit(11);
 153     }
 154 }
 155
 156 static void
 157 run_lock_timeout_gets_the_lock(void)
 158 {
 159     struct lockfile *lockfile;
 160
 161     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 162
 163     if (do_fork() == CHILD) {
 164         lockfile_unlock(lockfile);
 165         CHECK(lockfile_lock("file", TIME_UPDATE_INTERVAL * 3, &lockfile), 0);
 166         exit(11);
 167     } else {
 168         long long int now = time_msec();
 169         while (time_msec() < now + TIME_UPDATE_INTERVAL) {
 170             pause();
 171         }
 172         lockfile_unlock(lockfile);
 173     }
 174 }
 175
 176 static void
 177 run_lock_timeout_runs_out(void)
 178 {
 179     struct lockfile *lockfile;
 180
 181     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 182
 183     if (do_fork() == CHILD) {
 184         lockfile_unlock(lockfile);
 185         CHECK(lockfile_lock("file", TIME_UPDATE_INTERVAL, &lockfile),
 186               ETIMEDOUT);
 187         exit(11);
 188     } else {
 189         long long int now = time_msec();
 190         while (time_msec() < now + TIME_UPDATE_INTERVAL * 3) {
 191             pause();
 192         }
 193         lockfile_unlock(lockfile);
 194     }
 195 }
 196
 197 static void
 198 run_lock_multiple(void)
 199 {
 200     struct lockfile *a, *b, *c, *dummy;
 201
 202     CHECK(lockfile_lock("a", 0, &a), 0);
 203     CHECK(lockfile_lock("b", 0, &b), 0);
 204     CHECK(lockfile_lock("c", 0, &c), 0);
 205
 206     lockfile_unlock(a);
 207     CHECK(lockfile_lock("a", 0, &a), 0);
 208     CHECK(lockfile_lock("a", 0, &dummy), EDEADLK);
 209     lockfile_unlock(a);
 210
 211     lockfile_unlock(b);
 212     CHECK(lockfile_lock("a", 0, &a), 0);
 213
 214     lockfile_unlock(c);
 215     lockfile_unlock(a);
 216 }
 217
 218 /* Checks that locking a dangling symlink works OK.  (It used to hang.) */
 219 static void
 220 run_lock_symlink(void)
 221 {
 222     struct lockfile *a, *b, *dummy;
 223     struct stat s;
 224
 225     /* Create a symlink .a.~lock~ pointing to .b.~lock~. */
 226     CHECK(symlink(".b.~lock~", ".a.~lock~"), 0);
 227     CHECK(lstat(".a.~lock~", &s), 0);
 228     CHECK(S_ISLNK(s.st_mode) != 0, 1);
 229     CHECK(stat(".a.~lock~", &s), -1);
 230     CHECK(errno, ENOENT);
 231     CHECK(stat(".b.~lock~", &s), -1);
 232     CHECK(errno, ENOENT);
 233
 234     CHECK(lockfile_lock("a", 0, &a), 0);
 235     CHECK(lockfile_lock("a", 0, &dummy), EDEADLK);
 236     CHECK(lockfile_lock("b", 0, &dummy), EDEADLK);
 237     lockfile_unlock(a);
 238
 239     CHECK(lockfile_lock("b", 0, &b), 0);
 240     CHECK(lockfile_lock("b", 0, &dummy), EDEADLK);
 241     CHECK(lockfile_lock("a", 0, &dummy), EDEADLK);
 242     lockfile_unlock(b);
 243
 244     CHECK(lstat(".a.~lock~", &s), 0);
 245     CHECK(S_ISLNK(s.st_mode) != 0, 1);
 246     CHECK(stat(".a.~lock~", &s), 0);
 247     CHECK(S_ISREG(s.st_mode) != 0, 1);
 248     CHECK(stat(".b.~lock~", &s), 0);
 249     CHECK(S_ISREG(s.st_mode) != 0, 1);
 250 }
 251
 252 static void
 253 run_help(void)
 254 {
 255     size_t i;
 256
 257     printf("usage: %s TESTNAME\n"
 258            "where TESTNAME is one of the following:\n",
 259            program_name);
 260     for (i = 0; tests[i].name; i++) {
 261         fprintf(stderr, "\t%s\n", tests[i].name);
 262     }
 263 }
 264
 265 static const struct test tests[] = {
 266 #define TEST(NAME) { #NAME, run_##NAME }
 267     TEST(lock_and_unlock),
 268     TEST(lock_and_unlock_twice),
 269     TEST(lock_blocks_same_process),
 270     TEST(lock_blocks_same_process_twice),
 271     TEST(lock_blocks_other_process),
 272     TEST(lock_twice_blocks_other_process),
 273     TEST(lock_and_unlock_allows_other_process),
 274     TEST(lock_timeout_gets_the_lock),
 275     TEST(lock_timeout_runs_out),
 276     TEST(lock_multiple),
 277     TEST(lock_symlink),
 278     TEST(help),
 279     { NULL, NULL }
 280 #undef TEST
 281 };
 282
 283 int
 284 main(int argc, char *argv[])
 285 {
 286     extern struct vlog_module VLM_lockfile;
 287     size_t i;
 288
 289     set_program_name(argv[0]);
 290     vlog_set_levels(&VLM_lockfile, VLF_ANY_FACILITY, VLL_ERR);
 291
 292     if (argc != 2) {
 293         ovs_fatal(0, "exactly one argument required; use \"%s help\" for help",
 294                   program_name);
 295         return 1;
 296     }
 297
 298     for (i = 0; tests[i].name; i++) {
 299         if (!strcmp(argv[1], tests[i].name)) {
 300             int n_children;
 301             int status;
 302
 303             (tests[i].function)();
 304
 305             n_children = 0;
 306             while (wait(&status) > 0) {
 307                 if (WIFEXITED(status) && WEXITSTATUS(status) == 11) {
 308                     n_children++;
 309                 } else {
 310                     ovs_fatal(0, "child exited in unexpected way: %s",
 311                               process_status_msg(status));
 312                 }
 313             }
 314             if (errno != ECHILD) {
 315                 ovs_fatal(errno, "wait");
 316             }
 317
 318             printf("%s: success (%d child%s)\n",
 319                    tests[i].name, n_children, n_children != 1 ? "ren" : "");
 320             exit(0);
 321         }
 322     }
 323     ovs_fatal(0, "unknown test \"%s\"; use \"%s help\" for help",
 324               argv[1], program_name);
 325 }
 326