src/ath.c

   1 /* ath.c - A Thread-safeness library.
   2  *  Copyright (C) 2002, 2003, 2004, 2011 Free Software Foundation, Inc.
   3  *
   4  * This file is part of Libgcrypt.
   5  *
   6  * Libgcrypt is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser general Public License as
   8  * published by the Free Software Foundation; either version 2.1 of
   9  * the License, or (at your option) any later version.
  10  *
  11  * Libgcrypt is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #if USE_POSIX_THREADS_WEAK
  29 # include <pthread.h>
  30 #endif
  31
  32 #include "ath.h"
  33
  34
  35 \f
  36 /* On an ELF system it is easy to use pthreads using weak references.
  37    Take care not to test the address of a weak referenced function we
  38    actually use; some GCC versions have a bug were &foo != NULL is
  39    always evaluated to true in PIC mode.  USING_PTHREAD_AS_DEFAULT is
  40    used by ath_install to detect the default usage of pthread.  */
  41 #if USE_POSIX_THREADS_WEAK
  42 # pragma weak pthread_cancel
  43 # pragma weak pthread_mutex_init
  44 # pragma weak pthread_mutex_lock
  45 # pragma weak pthread_mutex_unlock
  46 # pragma weak pthread_mutex_destroy
  47 #endif
  48
  49 /* For the dummy interface.  The MUTEX_NOTINIT value is used to check
  50    that a mutex has been initialized.  */
  51 #define MUTEX_NOTINIT   ((ath_mutex_t) 0)
  52 #define MUTEX_UNLOCKED  ((ath_mutex_t) 1)
  53 #define MUTEX_LOCKED    ((ath_mutex_t) 2)
  54 #define MUTEX_DESTROYED ((ath_mutex_t) 3)
  55
  56
  57 /* Return the thread type from the option field. */
  58 #define GET_OPTION(a)    ((a) & 0xff)
  59
  60
  61 \f
  62 enum ath_thread_model {
  63   ath_model_undefined = 0,
  64   ath_model_none,          /* No thread support.  */
  65   ath_model_pthreads_weak, /* POSIX threads using weak symbols.  */
  66   ath_model_pthreads,      /* POSIX threads directly linked.  */
  67   ath_model_w32            /* Microsoft Windows threads.  */
  68 };
  69
  70
  71 /* The thread model in use.  */
  72 static enum ath_thread_model thread_model;
  73
  74
  75 /* Initialize the ath subsystem.  This is called as part of the
  76    Libgcrypt initialization.  It's purpose is to initialize the
  77    locking system.  It returns 0 on sucess or an ERRNO value on error.
  78    In the latter case it is not defined whether ERRNO was changed.
  79
  80    Note: This should be called as early as possible because it is not
  81    always possible to detect the thread model to use while already
  82    running multi threaded.  */
  83 int
  84 ath_init (void)
  85 {
  86   int err = 0;
  87
  88   if (thread_model)
  89     return 0; /* Already initialized - no error.  */
  90
  91   if (0)
  92     ;
  93 #if USE_POSIX_THREADS_WEAK
  94   else if (pthread_cancel)
  95     {
  96       thread_model = ath_model_pthreads_weak;
  97     }
  98 #endif
  99   else
 100     {
 101       /* Assume a single threaded application.  */
 102       thread_model = ath_model_none;
 103     }
 104
 105   return err;
 106 }
 107
 108
 109 /* Return the used thread model as string for display purposes an if
 110    R_MODEL is not null store its internal number at R_MODEL.  */
 111 const char *
 112 ath_get_model (int *r_model)
 113 {
 114   if (r_model)
 115     *r_model = thread_model;
 116   switch (thread_model)
 117     {
 118     case ath_model_undefined:     return "undefined";
 119     case ath_model_none:          return "none";
 120     case ath_model_pthreads_weak: return "pthread(weak)";
 121     case ath_model_pthreads:      return "pthread";
 122     case ath_model_w32:           return "w32";
 123     default:                      return "?";
 124     }
 125 }
 126
 127
 128 /* This function was used in old Libgcrypt versions (via
 129    GCRYCTL_SET_THREAD_CBS) to register the thread callback functions.
 130    It is not anymore required.  However to allow existing code to
 131    continue to work, we keep this function and check that no user
 132    defined callbacks are used and that the requested thread system
 133    matches the one Libgcrypt is using.  */
 134 gpg_err_code_t
 135 ath_install (struct ath_ops *ath_ops)
 136 {
 137   unsigned int thread_option;
 138
 139   /* Check if the requested thread option is compatible to the
 140      thread option we are already committed to.  */
 141   thread_option = ath_ops? GET_OPTION (ath_ops->option) : 0;
 142
 143   /* Return an error if the requested thread model does not match the
 144      configured one.  */
 145   if (0)
 146     ;
 147 #if USE_POSIX_THREADS_WEAK
 148   else if (thread_model == ath_model_pthreads_weak)
 149     {
 150       if (thread_option == ATH_THREAD_OPTION_PTHREAD)
 151         return 0; /* Okay - compatible.  */
 152     }
 153 #endif /*USE_POSIX_THREADS_WEAK*/
 154   else if (thread_option == ATH_THREAD_OPTION_DEFAULT)
 155     return 0; /* No thread support requested.  */
 156
 157   return GPG_ERR_NOT_SUPPORTED;
 158 }
 159
 160
 161 /* Initialize a new mutex.  This function returns 0 on success or an
 162    system error code (i.e. an ERRNO value).  ERRNO may or may not be
 163    changed on error.  */
 164 int
 165 ath_mutex_init (ath_mutex_t *lock)
 166 {
 167   int err;
 168
 169   switch (thread_model)
 170     {
 171     case ath_model_none:
 172       *lock = MUTEX_UNLOCKED;
 173       err = 0;
 174       break;
 175
 176 #if USE_POSIX_THREADS_WEAK
 177     case ath_model_pthreads_weak:
 178       {
 179         pthread_mutex_t *plck;
 180
 181         plck = malloc (sizeof *plck);
 182         if (!plck)
 183           err = errno? errno : ENOMEM;
 184         else
 185           {
 186             err = pthread_mutex_init (plck, NULL);
 187             if (err)
 188               free (plck);
 189             else
 190               *lock = (void*)plck;
 191           }
 192       }
 193       break;
 194 #endif /*USE_POSIX_THREADS_WEAK*/
 195
 196     default:
 197       err = EINVAL;
 198       break;
 199     }
 200
 201   return err;
 202 }
 203
 204
 205 /* Destroy a mutex.  This function is a NOP if LOCK is NULL.  If the
 206    mutex is still locked it can't be destroyed and the function
 207    returns EBUSY.  ERRNO may or may not be changed on error.  */
 208 int
 209 ath_mutex_destroy (ath_mutex_t *lock)
 210 {
 211   int err;
 212
 213   if (!*lock)
 214     return 0;
 215
 216   switch (thread_model)
 217     {
 218     case ath_model_none:
 219       if (*lock != MUTEX_UNLOCKED)
 220         err = EBUSY;
 221       else
 222         {
 223           *lock = MUTEX_DESTROYED;
 224           err = 0;
 225         }
 226       break;
 227
 228 #if USE_POSIX_THREADS_WEAK
 229     case ath_model_pthreads_weak:
 230       {
 231         pthread_mutex_t *plck = (pthread_mutex_t*) (*lock);
 232
 233         err = pthread_mutex_destroy (plck);
 234         if (!err)
 235           {
 236             free (plck);
 237             lock = NULL;
 238           }
 239       }
 240       break;
 241 #endif /*USE_POSIX_THREADS_WEAK*/
 242
 243     default:
 244       err = EINVAL;
 245       break;
 246     }
 247
 248   return err;
 249 }
 250
 251
 252 /* Lock the mutex LOCK.  On success the function returns 0; on error
 253    an error code.  ERRNO may or may not be changed on error.  */
 254 int
 255 ath_mutex_lock (ath_mutex_t *lock)
 256 {
 257   int err;
 258
 259   switch (thread_model)
 260     {
 261     case ath_model_none:
 262       if (*lock == MUTEX_NOTINIT)
 263         err = EINVAL;
 264       else if (*lock == MUTEX_UNLOCKED)
 265         {
 266           *lock = MUTEX_LOCKED;
 267           err = 0;
 268         }
 269       else
 270         err = EDEADLK;
 271       break;
 272
 273 #if USE_POSIX_THREADS_WEAK
 274     case ath_model_pthreads_weak:
 275       err = pthread_mutex_lock ((pthread_mutex_t*)(*lock));
 276       break;
 277 #endif /*USE_POSIX_THREADS_WEAK*/
 278
 279     default:
 280       err = EINVAL;
 281       break;
 282     }
 283
 284   return err;
 285 }
 286
 287 /* Unlock the mutex LOCK.  On success the function returns 0; on error
 288    an error code.  ERRNO may or may not be changed on error.  */
 289 int
 290 ath_mutex_unlock (ath_mutex_t *lock)
 291 {
 292   int err;
 293
 294   switch (thread_model)
 295     {
 296     case ath_model_none:
 297       if (*lock == MUTEX_NOTINIT)
 298         err = EINVAL;
 299       else if (*lock == MUTEX_LOCKED)
 300         {
 301           *lock = MUTEX_UNLOCKED;
 302           err = 0;
 303         }
 304       else
 305         err = EPERM;
 306       break;
 307
 308 #if USE_POSIX_THREADS_WEAK
 309     case ath_model_pthreads_weak:
 310       err = pthread_mutex_unlock ((pthread_mutex_t*)(*lock));
 311       break;
 312 #endif /*USE_POSIX_THREADS_WEAK*/
 313
 314     default:
 315       err = EINVAL;
 316       break;
 317     }
 318
 319   return err;
 320 }