mono/io-layer/critical-sections.c

   1 /*
   2  * critical-sections.c:  Critical sections
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * (C) 2002 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <pthread.h>
  13
  14 #include <mono/io-layer/wapi.h>
  15 #include <mono/io-layer/critical-section-private.h>
  16
  17 #include "mono-mutex.h"
  18
  19 /* A critical section is really just like a lightweight mutex. It
  20  * can't be waited for, and doesn't have a handle.
  21  */
  22
  23 /* According to the MSDN docs, the Microsoft implementation spins a
  24  * number of times then waits for a semaphore.  I could implement that
  25  * here but I'd need a mutex around the critical section structure
  26  * anyway.  So I may as well just use a pthread mutex.
  27  */
  28 static mono_once_t attr_key_once=MONO_ONCE_INIT;
  29 static mono_mutexattr_t attr;
  30
  31 static void attr_init(void)
  32 {
  33         int ret;
  34
  35         ret = mono_mutexattr_init(&attr);
  36         g_assert (ret == 0);
  37
  38         ret = mono_mutexattr_settype(&attr, MONO_MUTEX_RECURSIVE);
  39         g_assert (ret == 0);
  40 }
  41
  42 void _wapi_critical_section_cleanup (void)
  43 {
  44         mono_mutexattr_destroy (&attr);
  45 }
  46
  47 /**
  48  * InitializeCriticalSection:
  49  * @section: The critical section to initialise
  50  *
  51  * Initialises a critical section.
  52  */
  53 void InitializeCriticalSection(WapiCriticalSection *section)
  54 {
  55         int ret;
  56
  57         mono_once(&attr_key_once, attr_init);
  58         ret = mono_mutex_init(&section->mutex, &attr);
  59         g_assert (ret == 0);
  60 }
  61
  62 /**
  63  * InitializeCriticalSectionAndSpinCount:
  64  * @section: The critical section to initialise.
  65  * @spincount: The spin count for this critical section.  Not
  66  * currently used.
  67  *
  68  * Initialises a critical section and sets the spin count.  This
  69  * implementation just calls InitializeCriticalSection().
  70  *
  71  * Return value: %TRUE on success, %FALSE otherwise.  (%FALSE never
  72  * happens).
  73  */
  74 gboolean InitializeCriticalSectionAndSpinCount(WapiCriticalSection *section,
  75                                                guint32 spincount G_GNUC_UNUSED)
  76 {
  77         InitializeCriticalSection(section);
  78
  79         return(TRUE);
  80 }
  81
  82 /**
  83  * DeleteCriticalSection:
  84  * @section: The critical section to delete.
  85  *
  86  * Releases all resources owned by critical section @section.
  87  */
  88 void DeleteCriticalSection(WapiCriticalSection *section)
  89 {
  90         int ret;
  91
  92         ret = mono_mutex_destroy(&section->mutex);
  93         g_assert (ret == 0);
  94 }
  95
  96 /**
  97  * SetCriticalSectionSpinCount:
  98  * @section: The critical section to set
  99  * @spincount: The new spin count for this critical section.  Not
 100  * currently used.
 101  *
 102  * Sets the spin count for the critical section @section.  The spin
 103  * count is currently ignored, and set to zero.
 104  *
 105  * Return value: The previous spin count.  (Currently always zero).
 106  */
 107 guint32 SetCriticalSectionSpinCount(WapiCriticalSection *section G_GNUC_UNUSED, guint32 spincount G_GNUC_UNUSED)
 108 {
 109         return(0);
 110 }
 111
 112 /**
 113  * TryEnterCriticalSection:
 114  * @section: The critical section to try and enter
 115  *
 116  * Attempts to enter a critical section without blocking.  If
 117  * successful the calling thread takes ownership of the critical
 118  * section.
 119  *
 120  * A thread can recursively call EnterCriticalSection() and
 121  * TryEnterCriticalSection(), but must call LeaveCriticalSection() an
 122  * equal number of times.
 123  *
 124  * Return value: %TRUE if the thread successfully locked the critical
 125  * section, %FALSE otherwise.
 126  */
 127 gboolean TryEnterCriticalSection(WapiCriticalSection *section)
 128 {
 129         int ret;
 130
 131         ret=mono_mutex_trylock(&section->mutex);
 132         if(ret==0) {
 133                 return(TRUE);
 134         } else {
 135                 return(FALSE);
 136         }
 137 }
 138