1 /* $NetBSD: t_lockf.c,v 1.6 2013/02/19 04:58:40 pgoyette Exp $ */ 2 3 /*- 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <atf-c.h> 30 #include <err.h> 31 #include <errno.h> 32 #include <fcntl.h> 33 #include <signal.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <unistd.h> 38 39 #include <sys/types.h> 40 #include <sys/wait.h> 41 #include <sys/ptrace.h> 42 43 /* 44 * lockf1 regression test: 45 * 46 * Tests: 47 * Fork N child processes, each of which gets M random byte range locks 48 * on a common file. We ignore all lock errors (practically speaking, 49 * this means EDEADLK or ENOLOCK), but we make numerous passes over all 50 * the children to make sure that they are still awake. (We do this by 51 * verifying that we can ptrace(ATTACH/DETACH) to the children and get 52 * their status via waitpid().) 53 * When finished, reap all the children. 54 */ 55 56 #define nlocks 500 /* number of locks per thread */ 57 #define nprocs 10 /* number of processes to spawn */ 58 #define npasses 50 /* number of passes to make over the children */ 59 #define sleeptime 150000 /* sleep time between locks, usec */ 60 #define filesize 8192 /* size of file to lock */ 61 62 const char *lockfile = "lockf_test"; 63 64 static u_int32_t 65 random_uint32(void) 66 { 67 return lrand48(); 68 } 69 70 static void 71 trylocks(int id) 72 { 73 int i, ret, fd; 74 75 srand48(getpid()); 76 77 fd = open (lockfile, O_RDWR, 0); 78 79 if (fd < 0) 80 err(1, "%s", lockfile); 81 82 printf("%d: start\n", id); 83 84 for (i = 0; i < nlocks; i++) { 85 struct flock fl; 86 87 fl.l_start = random_uint32() % filesize; 88 fl.l_len = random_uint32() % filesize; 89 switch (random_uint32() % 3) { 90 case 0: 91 fl.l_type = F_RDLCK; 92 break; 93 case 1: 94 fl.l_type = F_WRLCK; 95 break; 96 case 2: 97 fl.l_type = F_UNLCK; 98 break; 99 } 100 fl.l_whence = SEEK_SET; 101 102 ret = fcntl(fd, F_SETLKW, &fl); 103 104 if (usleep(sleeptime) < 0) 105 err(1, "usleep"); 106 } 107 printf("%d: done\n", id); 108 close (fd); 109 } 110 111 ATF_TC(randlock); 112 ATF_TC_HEAD(randlock, tc) 113 { 114 115 atf_tc_set_md_var(tc, "timeout", "300"); 116 atf_tc_set_md_var(tc, "descr", "Checks fcntl(2) locking"); 117 } 118 119 ATF_TC_BODY(randlock, tc) 120 { 121 int i, j, fd; 122 int pipe_fd[2]; 123 pid_t *pid; 124 int status; 125 char pipe_in, pipe_out; 126 127 (void)unlink(lockfile); 128 129 fd = open (lockfile, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0666); 130 ATF_REQUIRE_MSG(fd >= 0, "open(%s): %s", lockfile, strerror(errno)); 131 132 ATF_REQUIRE_MSG(ftruncate(fd, filesize) >= 0, 133 "ftruncate(%s): %s", lockfile, strerror(errno)); 134 135 ATF_REQUIRE_MSG(pipe(pipe_fd) == 0, "pipe: %s", strerror(errno)); 136 137 fsync(fd); 138 close(fd); 139 140 pid = malloc(nprocs * sizeof(pid_t)); 141 142 for (i = 0; i < nprocs; i++) { 143 pipe_out = (char)('A' + i); 144 pid[i] = fork(); 145 switch (pid[i]) { 146 case 0: 147 if (write(pipe_fd[1], &pipe_out, 1) != 1) 148 printf("write_pipe(%i): %s", i, 149 strerror(errno)); 150 else 151 trylocks(i); 152 _exit(0); 153 break; 154 case -1: 155 atf_tc_fail("fork %d failed", i); 156 break; 157 default: 158 ATF_REQUIRE_MSG(read(pipe_fd[0], &pipe_in, 1) == 1, 159 "parent: read_pipe(%i): %s", i, strerror(errno)); 160 ATF_REQUIRE_MSG(pipe_in == pipe_out, 161 "parent: pipe does not match"); 162 break; 163 } 164 } 165 for (j = 0; j < npasses; j++) { 166 printf("parent: run %i\n", j+1); 167 for (i = 0; i < nprocs; i++) { 168 ATF_REQUIRE_MSG(ptrace(PT_ATTACH, pid[i], 0, 0) >= 0, 169 "ptrace attach %d", pid[i]); 170 ATF_REQUIRE_MSG(waitpid(pid[i], &status, WUNTRACED) >= 0, 171 "waitpid(ptrace)"); 172 usleep(sleeptime / 3); 173 ATF_REQUIRE_MSG(ptrace(PT_DETACH, pid[i], (caddr_t)1, 174 0) >= 0, 175 "ptrace detach %d", pid[i]); 176 usleep(sleeptime / 3); 177 } 178 } 179 for (i = 0; i < nprocs; i++) { 180 printf("reap %d: ", i); 181 fflush(stdout); 182 kill(pid[i], SIGINT); 183 waitpid(pid[i], &status, 0); 184 printf(" status %d\n", status); 185 } 186 atf_tc_pass(); 187 } 188 189 static int 190 dolock(int fd, int op, off_t lk_off, off_t lk_size) 191 { 192 off_t result; 193 int ret; 194 195 result = lseek(fd, lk_off, SEEK_SET); 196 if (result == -1) { 197 return errno; 198 } 199 ATF_REQUIRE_MSG(result == lk_off, "lseek to wrong offset"); 200 ret = lockf(fd, op, lk_size); 201 if (ret == -1) { 202 return errno; 203 } 204 return 0; 205 } 206 207 ATF_TC(deadlock); 208 ATF_TC_HEAD(deadlock, tc) 209 { 210 211 atf_tc_set_md_var(tc, "timeout", "30"); 212 atf_tc_set_md_var(tc, "descr", "Checks fcntl(2) deadlock detection"); 213 } 214 215 ATF_TC_BODY(deadlock, tc) 216 { 217 int fd; 218 int error; 219 int ret; 220 pid_t pid; 221 222 (void)unlink(lockfile); 223 224 fd = open (lockfile, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0666); 225 ATF_REQUIRE_MSG(fd >= 0, "open(%s): %s", lockfile, strerror(errno)); 226 227 ATF_REQUIRE_MSG(ftruncate(fd, filesize) >= 0, 228 "ftruncate(%s): %s", lockfile, strerror(errno)); 229 230 fsync(fd); 231 232 error = dolock(fd, F_LOCK, 0, 1); 233 ATF_REQUIRE_MSG(error == 0, "initial dolock: %s", strerror(errno)); 234 235 pid = fork(); 236 ATF_REQUIRE_MSG(pid != -1, "fork failed: %s", strerror(errno)); 237 if (pid == 0) { 238 error = dolock(fd, F_LOCK, 1, 1); 239 ATF_REQUIRE_MSG(error == 0, "child dolock: %s", 240 strerror(errno)); 241 dolock(fd, F_LOCK, 0, 1); /* will block */ 242 atf_tc_fail("child did not block"); 243 } 244 sleep(1); /* give child time to grab its lock then block */ 245 246 error = dolock(fd, F_LOCK, 1, 1); 247 ATF_REQUIRE_MSG(error == EDEADLK, "parent did not detect deadlock: %s", 248 strerror(errno)); 249 ret = kill(pid, SIGKILL); 250 ATF_REQUIRE_MSG(ret != -1, "failed to kill child: %s", strerror(errno)); 251 252 atf_tc_pass(); 253 } 254 255 ATF_TP_ADD_TCS(tp) 256 { 257 ATF_TP_ADD_TC(tp, randlock); 258 ATF_TP_ADD_TC(tp, deadlock); 259 260 return atf_no_error(); 261 } 262