util/tstflock.c

   1 /* This file is part of the Zebra server.
   2    Copyright (C) 1994-2009 Index Data
   3
   4 Zebra is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 */
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <yaz/test.h>
  23 #include <yaz/log.h>
  24 #if HAVE_SYS_TIME_H
  25 #include <sys/time.h>
  26 #endif
  27 #include <time.h>
  28
  29 #if HAVE_SYS_STAT_H
  30 #include <sys/stat.h>
  31 #endif
  32 #if HAVE_SYS_TYPES_H
  33 #include <sys/types.h>
  34 #endif
  35 #if HAVE_UNISTD_H
  36 #include <unistd.h>
  37 #endif
  38 #if HAVE_SYS_WAIT_H
  39 #include <sys/wait.h>
  40 #endif
  41
  42 #include <fcntl.h>
  43
  44 #ifdef WIN32
  45 #include <io.h>
  46 #endif
  47
  48 #if YAZ_POSIX_THREADS
  49 #include <pthread.h>
  50 #endif
  51 #ifdef WIN32
  52 #include <windows.h>
  53 #include <process.h>
  54 #endif
  55
  56 #include <idzebra/flock.h>
  57 #include <string.h>
  58
  59 static char seq[1000];
  60 static char *seqp = 0;
  61
  62 #define NUM_THREADS 100
  63
  64 #if YAZ_POSIX_THREADS
  65 pthread_cond_t sleep_cond = PTHREAD_COND_INITIALIZER;
  66 pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER;
  67 #endif
  68
  69 int test_fd = 0;
  70
  71 static void small_sleep(void)
  72 {
  73 #ifdef WIN32
  74     Sleep(2);
  75 #else
  76 #if YAZ_POSIX_THREADS
  77     struct timespec abstime;
  78     struct timeval now;
  79
  80     gettimeofday(&now, 0);
  81     abstime.tv_sec = now.tv_sec;
  82     abstime.tv_nsec = 1000000 + now.tv_usec * 1000;
  83     if (abstime.tv_nsec > 1000000000) /* 1s = 1e9 ns */
  84     {
  85         abstime.tv_nsec -= 1000000000;
  86         abstime.tv_sec++;
  87     }
  88     pthread_mutex_lock(&sleep_mutex);
  89     pthread_cond_timedwait(&sleep_cond, &sleep_mutex, &abstime);
  90     pthread_mutex_unlock(&sleep_mutex);
  91 #endif
  92 #endif
  93 }
  94
  95 void *run_func(void *arg)
  96 {
  97     int i;
  98     int *pdata = (int*) arg;
  99     int use_write_lock = *pdata;
 100     ZebraLockHandle lh = zebra_lock_create(0, "my.LCK");
 101     for (i = 0; i<2; i++)
 102     {
 103         int write_lock = use_write_lock;
 104
 105         if (use_write_lock == 2) /* random lock */
 106             write_lock = (rand() & 3) == 3 ? 1 : 0;
 107
 108         if (write_lock)
 109         {
 110             zebra_lock_w(lh);
 111
 112             write(test_fd, "L", 1);
 113             *seqp++ = 'L';
 114             small_sleep();
 115             *seqp++ = 'U';
 116             write(test_fd, "U", 1);
 117
 118             zebra_unlock(lh);
 119         }
 120         else
 121         {
 122             zebra_lock_r(lh);
 123
 124             write(test_fd, "l", 1);
 125             *seqp++ = 'l';
 126             small_sleep();
 127             *seqp++ = 'u';
 128             write(test_fd, "u", 1);
 129
 130             zebra_unlock(lh);
 131         }
 132     }
 133     zebra_lock_destroy(lh);
 134     *pdata = 123;
 135     return 0;
 136 }
 137
 138 #ifdef WIN32
 139 DWORD WINAPI ThreadProc(void *p)
 140 {
 141     run_func(p);
 142     return 0;
 143 }
 144 #endif
 145
 146 static void tst_thread(int num, int write_flag)
 147 {
 148 #ifdef WIN32
 149     HANDLE handles[NUM_THREADS];
 150     DWORD dwThreadId[NUM_THREADS];
 151 #endif
 152 #if YAZ_POSIX_THREADS
 153     pthread_t child_thread[NUM_THREADS];
 154 #endif
 155     int i, id[NUM_THREADS];
 156
 157     seqp = seq;
 158     assert (num <= NUM_THREADS);
 159     for (i = 0; i < num; i++)
 160     {
 161         id[i] = write_flag;
 162 #if YAZ_POSIX_THREADS
 163         pthread_create(&child_thread[i], 0 /* attr */, run_func, &id[i]);
 164 #endif
 165 #ifdef WIN32
 166         if (1)
 167         {
 168             void *pData = &id[i];
 169             handles[i] = CreateThread(
 170                 NULL,              /* default security attributes */
 171                 0,                 /* use default stack size */
 172                 ThreadProc,        /* thread function */
 173                 pData,             /* argument to thread function */
 174                 0,                 /* use default creation flags */
 175                 &dwThreadId[i]);   /* returns the thread identifier */
 176         }
 177
 178 #endif
 179     }
 180 #if YAZ_POSIX_THREADS
 181     for (i = 0; i<num; i++)
 182         pthread_join(child_thread[i], 0);
 183 #endif
 184 #ifdef WIN32
 185     WaitForMultipleObjects(num, handles, TRUE, INFINITE);
 186 #endif
 187     for (i = 0; i < num; i++)
 188         YAZ_CHECK(id[i] == 123);
 189     *seqp++ = '\0';
 190     yaz_log(YLOG_LOG, "tst_thread(%d,%d) returns seq=%s",
 191             num, write_flag, seq);
 192 }
 193
 194 static void tst(void)
 195 {
 196     tst_thread(4, 1); /* write locks */
 197     if (1)
 198     {
 199         int i = 0;
 200         while (seq[i])
 201         {
 202             YAZ_CHECK_EQ(seq[i], 'L');
 203             YAZ_CHECK_EQ(seq[i+1], 'U');
 204             i = i + 2;
 205         }
 206     }
 207
 208     tst_thread(6, 0);  /* read locks */
 209
 210     tst_thread(20, 2); /* random locks */
 211 }
 212
 213 void fork_tst(void)
 214 {
 215 #if HAVE_SYS_WAIT_H
 216     pid_t pid[2];
 217     int i;
 218
 219     for (i = 0; i<2; i++)
 220     {
 221         pid[i] = fork();
 222         if (!pid[i])
 223         {
 224             tst();
 225             exit(0);
 226         }
 227     }
 228     for (i = 0; i<2; i++)
 229     {
 230         int status;
 231         waitpid(pid[i], &status, 0);
 232         YAZ_CHECK(status == 0);
 233     }
 234 #else
 235     tst();
 236 #endif
 237 }
 238
 239 int main(int argc, char **argv)
 240 {
 241     YAZ_CHECK_INIT(argc, argv);
 242     YAZ_CHECK_LOG();
 243
 244     /* ensure the flock system logs in our test */
 245     yaz_log_init_level(yaz_log_mask_str("flock"));
 246
 247     zebra_flock_init();
 248
 249     test_fd = open("tstflock.out", (O_BINARY|O_CREAT|O_RDWR), 0666);
 250     YAZ_CHECK(test_fd != -1);
 251     if (test_fd != -1)
 252     {
 253         fork_tst();
 254     }
 255     YAZ_CHECK_TERM;
 256 }
 257
 258
 259 /*
 260  * Local variables:
 261  * c-basic-offset: 4
 262  * c-file-style: "Stroustrup"
 263  * indent-tabs-mode: nil
 264  * End:
 265  * vim: shiftwidth=4 tabstop=8 expandtab
 266  */
 267