tests/kernel/t_lockf.c

   1 /*      $NetBSD: t_lockf.c,v 1.9 2013/10/19 17:45:00 christos 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, 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                 (void)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         const char pipe_errmsg[] = "child: pipe write failed\n";
 127
 128         (void)unlink(lockfile);
 129
 130         fd = open (lockfile, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0666);
 131         ATF_REQUIRE_MSG(fd >= 0, "open(%s): %s", lockfile, strerror(errno));
 132
 133         ATF_REQUIRE_MSG(ftruncate(fd, filesize) >= 0,
 134             "ftruncate(%s): %s", lockfile, strerror(errno));
 135
 136         ATF_REQUIRE_MSG(pipe(pipe_fd) == 0, "pipe: %s", strerror(errno));
 137
 138         fsync(fd);
 139         close(fd);
 140
 141         pid = malloc(nprocs * sizeof(pid_t));
 142
 143         for (i = 0; i < nprocs; i++) {
 144                 pipe_out = (char)('A' + i);
 145                 pid[i] = fork();
 146                 switch (pid[i]) {
 147                 case 0:
 148                         if (write(pipe_fd[1], &pipe_out, 1) != 1)
 149                                 write(STDERR_FILENO, pipe_errmsg,
 150                                     __arraycount(pipe_errmsg) - 1);
 151                         else
 152                                 trylocks(i);
 153                         _exit(0);
 154                         break;
 155                 case -1:
 156                         atf_tc_fail("fork %d failed", i);
 157                         break;
 158                 default:
 159                         ATF_REQUIRE_MSG(read(pipe_fd[0], &pipe_in, 1) == 1,
 160                             "parent: read_pipe(%i): %s", i, strerror(errno));
 161                         ATF_REQUIRE_MSG(pipe_in == pipe_out,
 162                             "parent: pipe does not match");
 163                         break;
 164                 }
 165         }
 166         for (j = 0; j < npasses; j++) {
 167                 printf("parent: run %i\n", j+1);
 168                 for (i = 0; i < nprocs; i++) {
 169                         ATF_REQUIRE_MSG(ptrace(PT_ATTACH, pid[i], 0, 0) >= 0,
 170                             "ptrace attach %d", pid[i]);
 171                         ATF_REQUIRE_MSG(waitpid(pid[i], &status, WUNTRACED) >= 0,
 172                             "waitpid(ptrace)");
 173                         usleep(sleeptime / 3);
 174                         ATF_REQUIRE_MSG(ptrace(PT_DETACH, pid[i], (caddr_t)1,
 175                                                0) >= 0,
 176                             "ptrace detach %d", pid[i]);
 177                         usleep(sleeptime / 3);
 178                 }
 179         }
 180         for (i = 0; i < nprocs; i++) {
 181                 printf("reap %d: ", i);
 182                 fflush(stdout);
 183                 kill(pid[i], SIGINT);
 184                 waitpid(pid[i], &status, 0);
 185                 printf(" status %d\n", status);
 186         }
 187         atf_tc_pass();
 188 }
 189
 190 static int
 191 dolock(int fd, int op, off_t lk_off, off_t lk_size)
 192 {
 193         off_t result;
 194         int ret;
 195
 196         result = lseek(fd, lk_off, SEEK_SET);
 197         if (result == -1) {
 198                 return errno;
 199         }
 200         ATF_REQUIRE_MSG(result == lk_off, "lseek to wrong offset");
 201         ret = lockf(fd, op, lk_size);
 202         if (ret == -1) {
 203                 return errno;
 204         }
 205         return 0;
 206 }
 207
 208 ATF_TC(deadlock);
 209 ATF_TC_HEAD(deadlock, tc)
 210 {
 211
 212         atf_tc_set_md_var(tc, "timeout", "30");
 213         atf_tc_set_md_var(tc, "descr", "Checks fcntl(2) deadlock detection");
 214 }
 215
 216 ATF_TC_BODY(deadlock, tc)
 217 {
 218         int fd;
 219         int error;
 220         int ret;
 221         pid_t pid;
 222
 223         (void)unlink(lockfile);
 224
 225         fd = open (lockfile, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0666);
 226         ATF_REQUIRE_MSG(fd >= 0, "open(%s): %s", lockfile, strerror(errno));
 227
 228         ATF_REQUIRE_MSG(ftruncate(fd, filesize) >= 0,
 229             "ftruncate(%s): %s", lockfile, strerror(errno));
 230
 231         fsync(fd);
 232
 233         error = dolock(fd, F_LOCK, 0, 1);
 234         ATF_REQUIRE_MSG(error == 0, "initial dolock: %s", strerror(errno));
 235
 236         pid = fork();
 237         ATF_REQUIRE_MSG(pid != -1, "fork failed: %s", strerror(errno));
 238         if (pid == 0) {
 239                 error = dolock(fd, F_LOCK, 1, 1);
 240                 ATF_REQUIRE_MSG(error == 0, "child dolock: %s",
 241                     strerror(errno));
 242                 dolock(fd, F_LOCK, 0, 1);       /* will block */
 243                 atf_tc_fail("child did not block");
 244         }
 245         sleep(1);       /* give child time to grab its lock then block */
 246
 247         error = dolock(fd, F_LOCK, 1, 1);
 248         ATF_REQUIRE_MSG(error == EDEADLK, "parent did not detect deadlock: %s",
 249             strerror(errno));
 250         ret = kill(pid, SIGKILL);
 251         ATF_REQUIRE_MSG(ret != -1, "failed to kill child: %s", strerror(errno));
 252
 253         atf_tc_pass();
 254 }
 255
 256 ATF_TP_ADD_TCS(tp)
 257 {
 258         ATF_TP_ADD_TC(tp, randlock);
 259         ATF_TP_ADD_TC(tp, deadlock);
 260
 261         return atf_no_error();
 262 }