src/mutex.h

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015,
   3     2016
   4     Ben Kibbey <bjk@luxsci.net>
   5
   6     This file is part of pwmd.
   7
   8     Pwmd is free software: you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation, either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     Pwmd is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21 #ifndef MUTEX_H
  22 #define MUTEX_H
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #ifdef HAVE_SYS_TIME_H
  29 #include <sys/time.h>
  30 #endif
  31
  32 #ifdef HAVE_TIME_H
  33 #include <time.h>
  34 #endif
  35
  36 #ifdef HAVE_SYS_SELECT_H
  37 #include <sys/select.h>
  38 #else
  39 #include <sys/types.h>
  40 #include <unistd.h>
  41 #endif
  42
  43 #ifdef HAVE_SYS_FILE_H
  44 #include <sys/file.h>
  45 #endif
  46
  47 #ifdef HAVE_FCNTL_H
  48 #include <fcntl.h>
  49 #endif
  50
  51 #include <pthread.h>
  52 #include <assert.h>
  53 #include <errno.h>
  54 #include "rcfile.h"
  55
  56 #ifndef HAVE_PTHREAD_CANCEL
  57 pthread_key_t signal_thread_key;
  58 #define TEST_CANCEL() do {                                              \
  59       int *cancel = (int *) pthread_getspecific (signal_thread_key);    \
  60       if (cancel && *cancel)                                            \
  61         pthread_exit (NULL);                                            \
  62   } while (0)
  63 #else
  64 #define TEST_CANCEL()
  65 #endif
  66
  67 #define INIT_TIMESPEC(t, ts) do {                       \
  68         long s = (t*100000000)/1000000000;              \
  69         long l = (t*100000000)%1000000000;              \
  70         clock_gettime(CLOCK_REALTIME, &ts);             \
  71         ts.tv_sec += s;                                 \
  72         if (ts.tv_nsec + l >= 1000000000) {             \
  73             ts.tv_sec++;                                \
  74             ts.tv_nsec = 0;                             \
  75         }                                               \
  76         else                                            \
  77             ts.tv_nsec += l;                            \
  78     } while (0)
  79
  80 #ifdef MUTEX_DEBUG
  81 #define MUTEX_LOCK_DEBUG(m) do { \
  82         log_write("%s(%i): %s(): LOCK %p", __FILE__, __LINE__, \
  83                   __FUNCTION__, m);                            \
  84     } while (0)
  85
  86 #define MUTEX_UNLOCK_DEBUG(m) do { \
  87         log_write("%s(%i): %s(): UNLOCK %p", __FILE__, __LINE__, \
  88                   __FUNCTION__, m);                              \
  89     } while (0)
  90 #else
  91 #define MUTEX_LOCK_DEBUG(m)
  92 #define MUTEX_UNLOCK_DEBUG(m)
  93 #endif
  94
  95 #define MUTEX_LOCK(m) do {                              \
  96         MUTEX_LOCK_DEBUG(m);                            \
  97         while (pthread_mutex_trylock (m) == EBUSY) {    \
  98             struct timeval tv = { 0, 3000 };            \
  99             TEST_CANCEL ();                             \
 100             select (0, NULL, NULL, NULL, &tv);          \
 101         };                                              \
 102     } while (0)
 103
 104 #define MUTEX_UNLOCK(m) do {                    \
 105         MUTEX_UNLOCK_DEBUG(m);                  \
 106         pthread_mutex_unlock(m);                \
 107     } while (0)
 108
 109 #define TIMED_LOCK_DURATION     100000
 110 #ifdef HAVE_FLOCK
 111 #define TRY_FLOCK(ctx, fd, type, rc) do {                       \
 112         long ka = (long)config_get_integer ("global", "keepalive_interval"); \
 113         int to = config_get_integer ("global", "lock_timeout"); \
 114         for (long elapsed = 0; ; elapsed++) {                   \
 115             struct timeval tv = { 0, TIMED_LOCK_DURATION };     \
 116             int n = flock (fd, type|LOCK_NB);                   \
 117             if (n == -1 && errno == EWOULDBLOCK)                \
 118               {                                                 \
 119                 if (to == -1 || elapsed >= to) {                \
 120                     rc = GPG_ERR_LOCKED;                        \
 121                     break;                                      \
 122                 }                                               \
 123                 select (0, NULL, NULL, NULL, &tv);              \
 124                 if (ctx && ka && elapsed && !((elapsed+1*10) % (ka*10))) { \
 125                   rc = send_status (ctx, STATUS_KEEPALIVE, NULL); \
 126                   if (rc)                                       \
 127                     break;                                      \
 128                 }                                               \
 129                 TEST_CANCEL();                                  \
 130               }                                                 \
 131             else if (n == -1)                                   \
 132               rc = gpg_error_from_errno (errno);                \
 133             else                                                \
 134               break;                                            \
 135         }                                                       \
 136 } while (0)
 137 #else
 138 #define TRY_FLOCK(ctx, fd, type, rc) do {                       \
 139     rc = 0;                                                     \
 140 } while (0)
 141 #endif
 142
 143 #define MUTEX_TIMED_LOCK(ctx, m, timeout, rc) do {              \
 144         long ka = (long)config_get_integer ("global", "keepalive_interval"); \
 145         for (long elapsed = 0; ; elapsed++) {                   \
 146             struct timeval tv = { 0, TIMED_LOCK_DURATION };     \
 147             if (pthread_mutex_trylock(m) == EBUSY) {            \
 148                 if (timeout == -1 || elapsed >= timeout) {      \
 149                     rc = GPG_ERR_LOCKED;                        \
 150                     break;                                      \
 151                 }                                               \
 152                 select (0, NULL, NULL, NULL, &tv);              \
 153                 if (ctx && ka && elapsed && !((elapsed+1*10) % (ka*10))) { \
 154                   rc = send_status (ctx, STATUS_KEEPALIVE, NULL); \
 155                   if (rc)                                       \
 156                     break;                                      \
 157                 }                                               \
 158                 TEST_CANCEL();                                  \
 159             }                                                   \
 160             else {                                              \
 161                 MUTEX_LOCK_DEBUG(m);                            \
 162                 break;                                          \
 163             }                                                   \
 164         }                                                       \
 165     } while (0)
 166
 167 #define MUTEX_TRYLOCK(ctx, m, rc, t) do {                       \
 168         int n;                                                  \
 169         rc = 0;                                                 \
 170         if ((n = pthread_mutex_trylock(m)) == EBUSY) {          \
 171             if (t != -1) {                                      \
 172                 if (ctx)                                        \
 173                   rc = send_status(ctx, STATUS_LOCKED, NULL);   \
 174                 if (!rc && t != 0) {                            \
 175                     MUTEX_TIMED_LOCK(ctx, m, t, rc);            \
 176                 }                                               \
 177                 else if (!rc) {                                 \
 178                     MUTEX_LOCK_DEBUG(m);                        \
 179                 }                                               \
 180             }                                                   \
 181             else                                                \
 182                 rc = GPG_ERR_LOCKED;                            \
 183         }                                                       \
 184         else if (n)                                             \
 185             rc = gpg_error_from_errno(n);                       \
 186         else                                                    \
 187           {                                                     \
 188             MUTEX_LOCK_DEBUG(m);                                \
 189           }                                                     \
 190     } while (0)
 191
 192 #endif