test/lockf/lockf.c

   1 /*      $NetBSD: lockf.c,v 1.4 2000/07/30 09:16:06 jdolecek Exp $       */
   2 /* $DragonFly: src/test/lockf/lockf.c,v 1.1 2004/05/11 08:03:57 joerg Exp $ */
   3
   4 /*-
   5  * Copyright (c) 2000 The NetBSD Foundation, Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the NetBSD
  19  *      Foundation, Inc. and its contributors.
  20  * 4. Neither the name of The NetBSD Foundation nor the names of its
  21  *    contributors may be used to endorse or promote products derived
  22  *    from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  27  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  28  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 /*
  38  * lockf regression test:
  39  *
  40  * Tests:
  41  * 1) fork N child processes, do a bunch of random byte range lock/unlock.
  42  */
  43
  44 #include <sys/types.h>
  45 #include <sys/wait.h>
  46 #include <sys/ptrace.h>
  47
  48 #include <unistd.h>
  49 #include <fcntl.h>
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <err.h>
  53 #include <signal.h>
  54 #include <errno.h>
  55
  56 int nlocks = 10000;                     /* number of locks per thread */
  57 int nprocs = 100;               /* number of processes to spawn */
  58 int sleeptime = 50000;          /* sleep time between locks, usec */
  59 off_t size = 65536;             /* size of file to lock */
  60 const char *lockfile = "/tmp/lockf_test";
  61
  62 static uint32_t
  63 random_uint32(void)
  64 {
  65         return lrand48();
  66 }
  67
  68
  69 static void
  70 trylocks(int id)
  71 {
  72         int i, ret, fd;
  73         int uids[3];
  74         const char *which;
  75
  76         uids[0] = -1;
  77         uids[1] = getuid();
  78         uids[2] = geteuid();
  79         srand48(getpid());
  80
  81         fd = open (lockfile, O_RDWR, 0);
  82
  83         if (fd < 0)
  84                 err(1, lockfile);
  85
  86         printf("%d: start\n", id);
  87
  88         for (i=0; i<nlocks; i++) {
  89                 struct flock fl;
  90                 ret = random_uint32() % 3;
  91                 if (uids[ret] != -1) {
  92                         printf("switching to uid %d\n", uids[ret]);
  93                         setuid(uids[ret]);
  94                 }
  95
  96                 fl.l_start = random_uint32() % size;
  97                 fl.l_len = random_uint32() % size;
  98                 switch (random_uint32() % 3) {
  99                 case 0:
 100                         which = "read";
 101                         fl.l_type = F_RDLCK;
 102                         break;
 103                 case 1:
 104                         which = "write";
 105                         fl.l_type = F_WRLCK;
 106                         break;
 107                 case 2:
 108                         which = "un";
 109                         fl.l_type = F_UNLCK;
 110                         break;
 111                 }
 112                 fl.l_whence = SEEK_SET;
 113
 114                 printf("%d: try %slock %d to %d\n", id, which, (int)fl.l_start,
 115                     (int)(fl.l_start + fl.l_len));
 116
 117                 ret = fcntl(fd, F_SETLKW, &fl);
 118
 119                 if (ret < 0)
 120                         perror("fcntl");
 121                 printf("%d: got %slock %d to %d\n", id, which, (int)fl.l_start,
 122                     ((int)(fl.l_start + fl.l_len)));
 123
 124                 if (usleep(sleeptime) < 0)
 125                   err(1, "usleep");
 126         }
 127         printf("%d: done\n", id);
 128         close (fd);
 129 }
 130
 131 /* ARGSUSED */
 132 int
 133 main(int argc, char **argv)
 134 {
 135         int i, j;
 136         pid_t *pid;
 137         int status;
 138         int fd;
 139
 140         unlink(lockfile);
 141
 142         fd = open (lockfile, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0666);
 143         if (fd < 0)
 144                 err(1, "%s", lockfile);
 145
 146         if (ftruncate(fd, size) < 0)
 147                 err(1, "ftruncate of %s failed", lockfile);
 148
 149         fsync(fd);
 150         close(fd);
 151
 152         pid = malloc(nprocs * sizeof(pid_t));
 153
 154         for (i=0; i<nprocs; i++) {
 155                 pid[i] = fork();
 156                 switch (pid[i]) {
 157                 case 0:
 158                         trylocks(i);
 159                         _exit(0);
 160                         break;
 161                 case -1:
 162                         err(1, "fork failed");
 163                         break;
 164                 default:
 165                         break;
 166                 }
 167         }
 168         for (j=0; j<100; j++) {
 169                 printf("parent: run %i\n", j+1);
 170                 for (i=0; i<nprocs; i++) {
 171                         printf("stop %d\n", i);
 172                         if (ptrace(PT_ATTACH, pid[i], 0, 0) < 0)
 173                                 err(1, "ptrace attach %d", pid[i]);
 174                         printf("wait %d\n", i);
 175                         if (waitpid(pid[i], &status, WUNTRACED) < 0)
 176                                 err(1, "waitpid(ptrace)");
 177                         printf("awake %d\n", i);
 178                         usleep(sleeptime/3);
 179                         if (ptrace(PT_DETACH, pid[i], (caddr_t)1, 0) < 0)
 180                                 err(1, "ptrace detach %d", pid[i]);
 181                         printf("done %d\n", i);
 182                         usleep(sleeptime/3);
 183                 }
 184         }
 185         for (i=0; i<nprocs; i++) {
 186                 printf("reap %d: ", i);
 187                 fflush(stdout);
 188                 kill(pid[i], SIGINT);
 189                 waitpid(pid[i], &status, 0);
 190                 printf(" status %d\n", status);
 191         }
 192         exit(0);
 193         /* NOTREACHED */
 194 }