src/mutex.h

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