path: root/mysys/my_winsem.c

/*
 * -------------------------------------------------------------
 *
 * Module: my_semaphore.c  (Original: semaphore.c from pthreads library)
 *
 * Purpose:
 *	Semaphores aren't actually part of the PThreads standard.
 *	They are defined by the POSIX Standard:
 *
 *		POSIX 1003.1b-1993	(POSIX.1b)
 *
 * -------------------------------------------------------------
 *
 * Pthreads-win32 - POSIX Threads Library for Win32
 * Copyright (C) 1998
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA
 */

/*
  NEED_SEM is not used in MySQL and should only be needed under
  Windows CE.

  The big changes compared to the original version was to not allocate
  any additional memory in sem_init() but to instead store everthing
  we need in sem_t.

  TODO:
  To get HAVE_CREATESEMAPHORE we have to define the struct
  in my_semaphore.h
*/

#include "mysys_priv.h"
#ifdef __WIN__
#include "my_semaphore.h"
#include <errno.h>

/*
 DOCPUBLIC
      This function initializes an unnamed semaphore. the
      initial value of the semaphore is 'value'

 PARAMETERS
      sem	Pointer to an instance of sem_t

      pshared	If zero, this semaphore may only be shared between
		threads in the same process.
		If nonzero, the semaphore can be shared between
		processes

      value	Initial value of the semaphore counter

 RESULTS
      0		Successfully created semaphore,
     -1		Failed, error in errno

 ERRNO
      EINVAL	'sem' is not a valid semaphore,
      ENOSPC	A required resource has been exhausted,
      ENOSYS	Semaphores are not supported,
      EPERM	The process lacks appropriate privilege

*/

int
sem_init (sem_t *sem, int pshared, unsigned int value)
{
  int result = 0;

  if (pshared != 0)
  {
    /*
      We don't support creating a semaphore that can be shared between
      processes
     */
    result = EPERM;
  }
  else
  {
#ifndef HAVE_CREATESEMAPHORE
    sem->value = value;
    sem->event = CreateEvent(NULL,
			     FALSE,	/* manual reset */
			     FALSE,	/* initial state */
			     NULL);
    if (!sem->event)
      result = ENOSPC;
    else
    {
      if (value)
	SetEvent(sem->event);
      InitializeCriticalSection(&sem->sem_lock_cs);
    }
#else /* HAVE_CREATESEMAPHORE */
    *sem = CreateSemaphore (NULL,	 /* Always NULL */
			    value,	 /* Initial value */
			    0x7FFFFFFFL, /* Maximum value */
			    NULL);	 /* Name */
    if (!*sem)
      result = ENOSPC;
#endif /* HAVE_CREATESEMAPHORE */
  }
  if (result != 0)
  {
    errno = result;
    return -1;
  }
  return 0;
} /* sem_init */


/*
  DOCPUBLIC
       This function destroys an unnamed semaphore.

  PARAMETERS
       sem	Pointer to an instance of sem_t

 RESULTS
       0	Successfully destroyed semaphore,
       -1	Failed, error in errno
 ERRNO
       EINVAL	'sem' is not a valid semaphore,
       ENOSYS	Semaphores are not supported,
       EBUSY	Threads (or processes) are currently blocked on 'sem'
*/

int
sem_destroy (sem_t * sem)
{
  int result = 0;

#ifdef EXTRA_DEBUG
  if (sem == NULL || *sem == NULL)
  {
    errno=EINVAL;
    return;
  }
#endif /* EXTRA_DEBUG */

#ifndef HAVE_CREATESEMAPHORE
  if (! CloseHandle(sem->event))
    result = EINVAL;
  else
    DeleteCriticalSection(&sem->sem_lock_cs);
#else /* HAVE_CREATESEMAPHORE */
  if (!CloseHandle(*sem))
    result = EINVAL;
#endif /* HAVE_CREATESEMAPHORE */
  if (result)
  {
    errno = result;
    return -1;
  }
  *sem=0;					/* Safety */
  return 0;
} /* sem_destroy */


/*
 DOCPUBLIC
      This function tries to wait on a semaphore. If the
      semaphore value is greater than zero, it decreases
      its value by one. If the semaphore value is zero, then
      this function returns immediately with the error EAGAIN

 PARAMETERS
      sem	Pointer to an instance of sem_t

 RESULTS
      0		Successfully decreased semaphore,
      -1	Failed, error in errno

 ERRNO
      EAGAIN	The semaphore was already locked,
      EINVAL	'sem' is not a valid semaphore,
      ENOSYS	Semaphores are not supported,
      EINTR	The function was interrupted by a signal,
      EDEADLK	A deadlock condition was detected.
*/

int
sem_trywait(sem_t * sem)
{
#ifndef HAVE_CREATESEMAPHORE
  /* not yet implemented! */
  int errno = EINVAL;
  return -1;
#else /* HAVE_CREATESEMAPHORE */
#ifdef EXTRA_DEBUG
  if (sem == NULL || *sem == NULL)
  {
    errno=EINVAL;
    return -1;
  }
#endif /* EXTRA_DEBUG */
  if (WaitForSingleObject (*sem, 0) == WAIT_TIMEOUT)
  {
    errno= EAGAIN;
    return -1;
  }
  return 0;
#endif /* HAVE_CREATESEMAPHORE */

}				/* sem_trywait */


#ifndef HAVE_CREATESEMAPHORE

static void
ptw32_decrease_semaphore(sem_t * sem)
{
  EnterCriticalSection(&sem->sem_lock_cs);
  DBUG_ASSERT(sem->value != 0);
  sem->value--;
  if (sem->value != 0)
    SetEvent(sem->event);
  LeaveCriticalSection(&sem->sem_lock_cs);
}

static BOOL
ptw32_increase_semaphore(sem_t * sem, unsigned int n)
{
  BOOL result=FALSE;

  EnterCriticalSection(&sem->sem_lock_cs);
  if (sem->value + n > sem->value)
  {
    sem->value += n;
    SetEvent(sem->event);
    result = TRUE;
  }
  LeaveCriticalSection(&sem->sem_lock_cs);
  return result;
}

#endif /* HAVE_CREATESEMAPHORE */


/*
 ------------------------------------------------------
 DOCPUBLIC
      This function waits on a semaphore. If the
      semaphore value is greater than zero, it decreases
      its value by one. If the semaphore value is zero, then
      the calling thread (or process) is blocked until it can
      successfully decrease the value or until interrupted by
      a signal.

 PARAMETERS
      sem	Pointer to an instance of sem_t

 RESULTS
      0		Successfully decreased semaphore,
     -1		Failed, error in errno

 ERRNO
      EINVAL	'Sem' is not a valid semaphore,
      ENOSYS	Semaphores are not supported,
      EINTR	The function was interrupted by a signal,
      EDEADLK	A deadlock condition was detected.
*/

int
sem_wait(sem_t *sem)
{
  int result;

#ifdef EXTRA_DEBUG
  if (sem == NULL || *sem == NULL)
  {
    errno=EINVAL;
    return -1;
  }
#endif /* EXTRA_DEBUG */

#ifndef HAVE_CREATESEMAPHORE
  result=WaitForSingleObject(sem->event, INFINITE);
#else
  result=WaitForSingleObject(*sem, INFINITE);
#endif
  if (result == WAIT_FAILED || result == WAIT_ABANDONED_0)
    result = EINVAL;
  else if (result == WAIT_TIMEOUT)
    result = ETIMEDOUT;
  else
    result=0;
  if (result)
  {
    errno = result;
    return -1;
  }
#ifndef HAVE_CREATESEMAPHORE
  ptw32_decrease_semaphore(sem);
#endif /* HAVE_CREATESEMAPHORE */
  return 0;
}


/*
 ------------------------------------------------------
 DOCPUBLIC
      This function posts a wakeup to a semaphore. If there
      are waiting threads (or processes), one is awakened;
      otherwise, the semaphore value is incremented by one.

 PARAMETERS
      sem		Pointer to an instance of sem_t

 RESULTS
      0			Successfully posted semaphore,
      -1		Failed, error in errno

 ERRNO
      EINVAL		'sem' is not a valid semaphore,
      ENOSYS		Semaphores are not supported,

*/

int
sem_post (sem_t * sem)
{
#ifdef EXTRA_DEBUG
  if (sem == NULL || *sem == NULL)
  {
    errno=EINVAL;
    return -1;
  }
#endif /* EXTRA_DEBUG */

#ifndef HAVE_CREATESEMAPHORE
  if (! ptw32_increase_semaphore(sem, 1))
#else /* HAVE_CREATESEMAPHORE */
  if (! ReleaseSemaphore(*sem, 1, 0))
#endif /* HAVE_CREATESEMAPHORE */
  {
    errno=EINVAL;
    return -1;
  }
  return 0;
}


/*
 ------------------------------------------------------
 DOCPUBLIC
      This function posts multiple wakeups to a semaphore. If there
      are waiting threads (or processes), n <= count are awakened;
      the semaphore value is incremented by count - n.

 PARAMETERS
      sem		Pointer to an instance of sem_t
      count		Counter, must be greater than zero.

 RESULTS
      0			Successfully posted semaphore,
      -1		Failed, error in errno

 ERRNO
      EINVAL		'sem' is not a valid semaphore or count is less
			than or equal to zero.
*/

int
sem_post_multiple (sem_t * sem, unsigned int count)
{
#ifdef EXTRA_DEBUG
  if (sem == NULL || *sem == NULL || count <= 0)
  {
    errno=EINVAL;
    return -1;
  }
#endif /* EXTRA_DEBUG */
#ifndef HAVE_CREATESEMAPHORE
  if (! ptw32_increase_semaphore (sem, count))
#else /* HAVE_CREATESEMAPHORE */
  if (! ReleaseSemaphore(*sem, count, 0))
#endif /* HAVE_CREATESEMAPHORE */
  {
    errno = EINVAL;
    return -1;
  }
  return 0;
}

int
sem_getvalue (sem_t *sem, unsigned int *sval)
{
  errno = ENOSYS;
  return -1;
}				/* sem_getvalue */

#endif /* __WIN__ */