pintos-os.org Git - openvswitch/blob - tests/test-lockfile.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011 Nicira Networks.
   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/wait.h>
  24 #include <unistd.h>
  25
  26 #include "process.h"
  27 #include "timeval.h"
  28 #include "util.h"
  29 #include "vlog.h"
  30
  31 struct test {
  32     const char *name;
  33     void (*function)(void);
  34 };
  35
  36 static const struct test tests[];
  37
  38 #define CHECK(A, B) check(A, B, #A, #B, __FILE__, __LINE__)
  39 static void
  40 check(int a, int b,
  41       const char *a_string, const char *b_string, const char *file, int line)
  42 {
  43     if (a != b) {
  44         fprintf(stderr, "%s:%d: expected %s == %s but %d != %d\n",
  45                 file, line, a_string, b_string, a, b);
  46         fflush(stderr);
  47         abort();
  48     }
  49 }
  50
  51 static void
  52 run_lock_and_unlock(void)
  53 {
  54     struct lockfile *lockfile;
  55
  56     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  57     lockfile_unlock(lockfile);
  58 }
  59
  60 static void
  61 run_lock_and_unlock_twice(void)
  62 {
  63     struct lockfile *lockfile;
  64
  65     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  66     lockfile_unlock(lockfile);
  67
  68     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  69     lockfile_unlock(lockfile);
  70 }
  71
  72 static void
  73 run_lock_blocks_same_process(void)
  74 {
  75     struct lockfile *lockfile;
  76
  77     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  78     CHECK(lockfile_lock("file", 0, &lockfile), EDEADLK);
  79     lockfile_unlock(lockfile);
  80 }
  81
  82 static void
  83 run_lock_blocks_same_process_twice(void)
  84 {
  85     struct lockfile *lockfile;
  86
  87     CHECK(lockfile_lock("file", 0, &lockfile), 0);
  88     CHECK(lockfile_lock("file", 0, &lockfile), EDEADLK);
  89     CHECK(lockfile_lock("file", 0, &lockfile), EDEADLK);
  90     lockfile_unlock(lockfile);
  91 }
  92
  93 static enum { PARENT, CHILD }
  94 do_fork(void)
  95 {
  96     switch (fork()) {
  97     case 0:
  98         time_postfork();
  99         lockfile_postfork();
 100         return CHILD;
 101
 102     default:
 103         return PARENT;
 104
 105     case -1:
 106         /* Error. */
 107         ovs_fatal(errno, "fork failed");
 108     }
 109 }
 110
 111 static void
 112 run_lock_blocks_other_process(void)
 113 {
 114     /* Making this static prevents a memory leak warning from valgrind for the
 115      * parent process, which cannot easily unlock (and free) 'lockfile' because
 116      * it can only do so after the child has exited, and it's the caller of
 117      * this function that does the wait() call. */
 118     static struct lockfile *lockfile;
 119
 120     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 121     if (do_fork() == CHILD) {
 122         lockfile_unlock(lockfile);
 123         CHECK(lockfile_lock("file", 0, &lockfile), EAGAIN);
 124         exit(11);
 125     }
 126 }
 127
 128 static void
 129 run_lock_twice_blocks_other_process(void)
 130 {
 131     struct lockfile *lockfile, *dummy;
 132
 133     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 134     CHECK(lockfile_lock("file", 0, &dummy), EDEADLK);
 135     if (do_fork() == CHILD) {
 136         CHECK(lockfile_lock("file", 0, &dummy), EAGAIN);
 137         exit(11);
 138     }
 139 }
 140
 141 static void
 142 run_lock_and_unlock_allows_other_process(void)
 143 {
 144     struct lockfile *lockfile;
 145
 146     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 147     lockfile_unlock(lockfile);
 148
 149     if (do_fork() == CHILD) {
 150         CHECK(lockfile_lock("file", 0, &lockfile), 0);
 151         exit(11);
 152     }
 153 }
 154
 155 static void
 156 run_lock_timeout_gets_the_lock(void)
 157 {
 158     struct lockfile *lockfile;
 159
 160     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 161
 162     if (do_fork() == CHILD) {
 163         lockfile_unlock(lockfile);
 164         CHECK(lockfile_lock("file", TIME_UPDATE_INTERVAL * 3, &lockfile), 0);
 165         exit(11);
 166     } else {
 167         long long int now = time_msec();
 168         while (time_msec() < now + TIME_UPDATE_INTERVAL) {
 169             pause();
 170         }
 171         lockfile_unlock(lockfile);
 172     }
 173 }
 174
 175 static void
 176 run_lock_timeout_runs_out(void)
 177 {
 178     struct lockfile *lockfile;
 179
 180     CHECK(lockfile_lock("file", 0, &lockfile), 0);
 181
 182     if (do_fork() == CHILD) {
 183         lockfile_unlock(lockfile);
 184         CHECK(lockfile_lock("file", TIME_UPDATE_INTERVAL, &lockfile),
 185               ETIMEDOUT);
 186         exit(11);
 187     } else {
 188         long long int now = time_msec();
 189         while (time_msec() < now + TIME_UPDATE_INTERVAL * 3) {
 190             pause();
 191         }
 192         lockfile_unlock(lockfile);
 193     }
 194 }
 195
 196 static void
 197 run_lock_multiple(void)
 198 {
 199     struct lockfile *a, *b, *c, *dummy;
 200
 201     CHECK(lockfile_lock("a", 0, &a), 0);
 202     CHECK(lockfile_lock("b", 0, &b), 0);
 203     CHECK(lockfile_lock("c", 0, &c), 0);
 204
 205     lockfile_unlock(a);
 206     CHECK(lockfile_lock("a", 0, &a), 0);
 207     CHECK(lockfile_lock("a", 0, &dummy), EDEADLK);
 208     lockfile_unlock(a);
 209
 210     lockfile_unlock(b);
 211     CHECK(lockfile_lock("a", 0, &a), 0);
 212
 213     lockfile_unlock(c);
 214     lockfile_unlock(a);
 215 }
 216
 217 static void
 218 run_help(void)
 219 {
 220     size_t i;
 221
 222     printf("usage: %s TESTNAME\n"
 223            "where TESTNAME is one of the following:\n",
 224            program_name);
 225     for (i = 0; tests[i].name; i++) {
 226         fprintf(stderr, "\t%s\n", tests[i].name);
 227     }
 228 }
 229
 230 static const struct test tests[] = {
 231 #define TEST(NAME) { #NAME, run_##NAME }
 232     TEST(lock_and_unlock),
 233     TEST(lock_and_unlock_twice),
 234     TEST(lock_blocks_same_process),
 235     TEST(lock_blocks_same_process_twice),
 236     TEST(lock_blocks_other_process),
 237     TEST(lock_twice_blocks_other_process),
 238     TEST(lock_and_unlock_allows_other_process),
 239     TEST(lock_timeout_gets_the_lock),
 240     TEST(lock_timeout_runs_out),
 241     TEST(lock_multiple),
 242     TEST(help),
 243     { NULL, NULL }
 244 #undef TEST
 245 };
 246
 247 int
 248 main(int argc, char *argv[])
 249 {
 250     extern struct vlog_module VLM_lockfile;
 251     size_t i;
 252
 253     set_program_name(argv[0]);
 254     vlog_set_levels(&VLM_lockfile, VLF_ANY_FACILITY, VLL_ERR);
 255
 256     if (argc != 2) {
 257         ovs_fatal(0, "exactly one argument required; use \"%s help\" for help",
 258                   program_name);
 259         return 1;
 260     }
 261
 262     for (i = 0; tests[i].name; i++) {
 263         if (!strcmp(argv[1], tests[i].name)) {
 264             int n_children;
 265             int status;
 266
 267             (tests[i].function)();
 268
 269             n_children = 0;
 270             while (wait(&status) > 0) {
 271                 if (WIFEXITED(status) && WEXITSTATUS(status) == 11) {
 272                     n_children++;
 273                 } else {
 274                     ovs_fatal(0, "child exited in unexpected way: %s",
 275                               process_status_msg(status));
 276                 }
 277             }
 278             if (errno != ECHILD) {
 279                 ovs_fatal(errno, "wait");
 280             }
 281
 282             printf("%s: success (%d child%s)\n",
 283                    tests[i].name, n_children, n_children != 1 ? "ren" : "");
 284             exit(0);
 285         }
 286     }
 287     ovs_fatal(0, "unknown test \"%s\"; use \"%s help\" for help",
 288               argv[1], program_name);
 289 }
 290