lockfile: Fix hang locking through a dangling symlink.
[sliver-openvswitch.git] / 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