gnulib/import/windows-recmutex.c

   1 /* Plain recursive mutexes (native Windows implementation).
   2    Copyright (C) 2005-2022 Free Software Foundation, Inc.
   3
   4    This file is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    License, or (at your option) any later version.
   8
   9    This file is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2005.
  18    Based on GCC's gthr-win32.h.  */
  19
  20 #include <config.h>
  21
  22 /* Specification.  */
  23 #include "windows-recmutex.h"
  24
  25 #include <errno.h>
  26
  27 void
  28 glwthread_recmutex_init (glwthread_recmutex_t *mutex)
  29 {
  30   mutex->owner = 0;
  31   mutex->depth = 0;
  32   InitializeCriticalSection (&mutex->lock);
  33   mutex->guard.done = 1;
  34 }
  35
  36 int
  37 glwthread_recmutex_lock (glwthread_recmutex_t *mutex)
  38 {
  39   if (!mutex->guard.done)
  40     {
  41       if (InterlockedIncrement (&mutex->guard.started) == 0)
  42         /* This thread is the first one to need this mutex.  Initialize it.  */
  43         glwthread_recmutex_init (mutex);
  44       else
  45         {
  46           /* Don't let mutex->guard.started grow and wrap around.  */
  47           InterlockedDecrement (&mutex->guard.started);
  48           /* Yield the CPU while waiting for another thread to finish
  49              initializing this mutex.  */
  50           while (!mutex->guard.done)
  51             Sleep (0);
  52         }
  53     }
  54   {
  55     DWORD self = GetCurrentThreadId ();
  56     if (mutex->owner != self)
  57       {
  58         EnterCriticalSection (&mutex->lock);
  59         mutex->owner = self;
  60       }
  61     if (++(mutex->depth) == 0) /* wraparound? */
  62       {
  63         mutex->depth--;
  64         return EAGAIN;
  65       }
  66   }
  67   return 0;
  68 }
  69
  70 int
  71 glwthread_recmutex_trylock (glwthread_recmutex_t *mutex)
  72 {
  73   if (!mutex->guard.done)
  74     {
  75       if (InterlockedIncrement (&mutex->guard.started) == 0)
  76         /* This thread is the first one to need this mutex.  Initialize it.  */
  77         glwthread_recmutex_init (mutex);
  78       else
  79         {
  80           /* Don't let mutex->guard.started grow and wrap around.  */
  81           InterlockedDecrement (&mutex->guard.started);
  82           /* Let another thread finish initializing this mutex, and let it also
  83              lock this mutex.  */
  84           return EBUSY;
  85         }
  86     }
  87   {
  88     DWORD self = GetCurrentThreadId ();
  89     if (mutex->owner != self)
  90       {
  91         if (!TryEnterCriticalSection (&mutex->lock))
  92           return EBUSY;
  93         mutex->owner = self;
  94       }
  95     if (++(mutex->depth) == 0) /* wraparound? */
  96       {
  97         mutex->depth--;
  98         return EAGAIN;
  99       }
 100   }
 101   return 0;
 102 }
 103
 104 int
 105 glwthread_recmutex_unlock (glwthread_recmutex_t *mutex)
 106 {
 107   if (mutex->owner != GetCurrentThreadId ())
 108     return EPERM;
 109   if (mutex->depth == 0)
 110     return EINVAL;
 111   if (--(mutex->depth) == 0)
 112     {
 113       mutex->owner = 0;
 114       LeaveCriticalSection (&mutex->lock);
 115     }
 116   return 0;
 117 }
 118
 119 int
 120 glwthread_recmutex_destroy (glwthread_recmutex_t *mutex)
 121 {
 122   if (mutex->owner != 0)
 123     return EBUSY;
 124   DeleteCriticalSection (&mutex->lock);
 125   mutex->guard.done = 0;
 126   return 0;
 127 }