libguile/threads-plugin.c

   1 /* Copyright (C) 2002 Free Software Foundation, Inc.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2, or (at your option)
   6  * any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this software; see the file COPYING.  If not, write to
  15  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  16  * Boston, MA 02111-1307 USA
  17  *
  18  * As a special exception, the Free Software Foundation gives permission
  19  * for additional uses of the text contained in its release of GUILE.
  20  *
  21  * The exception is that, if you link the GUILE library with other files
  22  * to produce an executable, this does not by itself cause the
  23  * resulting executable to be covered by the GNU General Public License.
  24  * Your use of that executable is in no way restricted on account of
  25  * linking the GUILE library code into it.
  26  *
  27  * This exception does not however invalidate any other reasons why
  28  * the executable file might be covered by the GNU General Public License.
  29  *
  30  * This exception applies only to the code released by the
  31  * Free Software Foundation under the name GUILE.  If you copy
  32  * code from other Free Software Foundation releases into a copy of
  33  * GUILE, as the General Public License permits, the exception does
  34  * not apply to the code that you add in this way.  To avoid misleading
  35  * anyone as to the status of such modified files, you must delete
  36  * this exception notice from them.
  37  *
  38  * If you write modifications of your own for GUILE, it is your choice
  39  * whether to permit this exception to apply to your modifications.
  40  * If you do not wish that, delete this exception notice.  */
  41
  42
  43 \f
  44
  45 int scm_i_plugin_mutex_size = 0;
  46 int (*scm_i_plugin_mutex_init) (scm_t_mutex *, const scm_t_mutexattr *);
  47 int (*scm_i_plugin_mutex_lock) (scm_t_mutex *);
  48 int (*scm_i_plugin_mutex_unlock) (scm_t_mutex *);
  49
  50 int scm_i_plugin_rec_mutex_size = 0;
  51 int (*scm_i_plugin_rec_mutex_init) (scm_t_rec_mutex *,
  52                                     const scm_t_mutexattr *);
  53 int (*scm_i_plugin_rec_mutex_destroy) (scm_t_rec_mutex *);
  54 int (*scm_i_plugin_rec_mutex_lock) (scm_t_rec_mutex *);
  55 int (*scm_i_plugin_rec_mutex_trylock) (scm_t_rec_mutex *);
  56 int (*scm_i_plugin_rec_mutex_unlock) (scm_t_rec_mutex *);
  57
  58 int (*scm_i_plugin_cond_wait) (scm_t_cond *, scm_t_mutex *);
  59 int (*scm_i_plugin_cond_timedwait) (scm_t_cond *,
  60                                     scm_t_mutex *,
  61                                     const struct timespec *);
  62
  63 typedef struct rec_mutex {
  64 #ifdef SCM_DEBUG_THREADS
  65   int kind;
  66 #endif
  67   scm_t_mutex mutex;
  68   scm_thread *owner;
  69   int count;
  70 } rec_mutex;
  71
  72 /* Mutex for recursive mutex administration */
  73 static scm_t_mutex rec_mutex_mutex;
  74
  75 static int
  76 rec_mutex_init (scm_t_rec_mutex *mx, const scm_t_mutexattr *a)
  77 {
  78   rec_mutex *m = (rec_mutex *) mx;
  79   scm_i_plugin_mutex_init (&m->mutex, &scm_i_plugin_mutex);
  80   m->owner = 0;
  81   m->count = 0;
  82 #ifdef SCM_DEBUG_THREADS
  83   m->kind = REC_MUTEX;
  84 #endif
  85   return 0;
  86 }
  87
  88 static int
  89 rec_mutex_destroy (scm_t_rec_mutex *mx)
  90 {
  91   rec_mutex *m = (rec_mutex *) mx;
  92   return scm_i_plugin_mutex_destroy (&m->mutex);
  93 }
  94
  95 static int
  96 rec_mutex_lock (scm_t_rec_mutex *mx)
  97 {
  98   rec_mutex *m = (rec_mutex *) mx;
  99   scm_thread *t = SCM_CURRENT_THREAD;
 100   scm_i_plugin_mutex_lock (&rec_mutex_mutex);
 101 #ifdef SCM_DEBUG_THREADS
 102   if (m->kind != REC_MUTEX)
 103     {
 104       fprintf (stderr,
 105                m->kind == FAST_MUTEX
 106                ? "locking wrong mutex type\n"
 107                : "locking uninitialized mutex\n");
 108       abort ();
 109     }
 110 #endif
 111   if (m->count && m->owner == t)
 112     {
 113       ++m->count;
 114       scm_i_plugin_mutex_unlock (&rec_mutex_mutex);
 115     }
 116   else
 117     {
 118       scm_i_plugin_mutex_unlock (&rec_mutex_mutex);
 119       scm_i_plugin_mutex_lock (&m->mutex);
 120       m->count = 1;
 121       m->owner = t;
 122     }
 123   return 0;
 124 }
 125
 126 static int
 127 rec_mutex_trylock (scm_t_rec_mutex *mx)
 128 {
 129   rec_mutex *m = (rec_mutex *) mx;
 130   scm_thread *t = SCM_CURRENT_THREAD;
 131   scm_i_plugin_mutex_lock (&rec_mutex_mutex);
 132   if (m->owner != 0 && m->owner != t)
 133     return EBUSY;
 134   else if (m->count)
 135     {
 136       ++m->count;
 137       scm_i_plugin_mutex_unlock (&rec_mutex_mutex);
 138     }
 139   else
 140     {
 141       scm_i_plugin_mutex_unlock (&rec_mutex_mutex);
 142       scm_i_plugin_mutex_lock (&m->mutex);
 143       m->count = 1;
 144       m->owner = t;
 145     }
 146   return 0;
 147 }
 148
 149 static int
 150 rec_mutex_unlock (scm_t_rec_mutex *mx)
 151 {
 152   rec_mutex *m = (rec_mutex *) mx;
 153   scm_i_plugin_mutex_lock (&rec_mutex_mutex);
 154 #ifdef SCM_DEBUG_THREADS
 155   if (m->kind != REC_MUTEX)
 156     {
 157       fprintf (stderr,
 158                m->kind == FAST_MUTEX
 159                ? "locking wrong mutex type\n"
 160                : "locking uninitialized mutex\n");
 161       abort ();
 162     }
 163   if (m->count == 0)
 164     {
 165       fprintf (stderr, "unlocking unlocked mutex\n");
 166       abort ();
 167     }
 168 #endif
 169   if (!--m->count)
 170     {
 171       m->owner = 0;
 172       scm_i_plugin_mutex_unlock (&m->mutex);
 173     }
 174   scm_i_plugin_mutex_unlock (&rec_mutex_mutex);
 175   return 0;
 176 }
 177
 178 #ifndef SCM_MUTEXATTR_SETTYPE_DECLARED
 179 int pthread_mutexattr_settype (pthread_mutexattr_t *, int);
 180 #endif
 181
 182 void
 183 scm_init_threads_plugin ()
 184 {
 185   if (scm_i_plugin_rec_mutex_size == 0)
 186     {
 187       scm_i_plugin_rec_mutex_size = sizeof (rec_mutex);
 188       scm_i_plugin_mutex_init (&rec_mutex_mutex, &scm_i_plugin_mutex);
 189       scm_i_plugin_rec_mutex_init = rec_mutex_init;
 190       scm_i_plugin_rec_mutex_destroy = rec_mutex_destroy;
 191       scm_i_plugin_rec_mutex_lock = rec_mutex_lock;
 192       scm_i_plugin_rec_mutex_trylock = rec_mutex_trylock;
 193       scm_i_plugin_rec_mutex_unlock = rec_mutex_unlock;
 194     }
 195   if (scm_i_plugin_mutex_size > SCM_MUTEX_MAXSIZE
 196       || scm_i_plugin_rec_mutex_size > SCM_REC_MUTEX_MAXSIZE)
 197     {
 198       fprintf (stderr, "Internal error: Need to upgrade mutex size\n");
 199       abort ();
 200     }
 201 }