sal/osl/os2/semaphor.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: semaphor.c,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "system.h"
  32
  33 #include <osl/diagnose.h>
  34 #include <osl/semaphor.h>
  35
  36 /*
  37     Implemetation notes:
  38     The void* represented by oslSemaphore is used
  39     to store a OS/2 HANDLE.
  40 */
  41
  42 typedef struct _oslSemaphoreImpl
  43 {
  44     HEV hevReachedZero;
  45     int nCount;
  46 } oslSemaphoreImpl;
  47
  48 // static mutex to control access to private members of oslMutexImpl
  49 static HMTX MutexLock = NULL;
  50
  51 /*****************************************************************************/
  52 /* osl_createSemaphore */
  53 /*****************************************************************************/
  54
  55 /*
  56 - Erzeugen der Semaphore
  57 - Z„hler auf initialCount setzen
  58 */
  59 oslSemaphore SAL_CALL osl_createSemaphore(sal_uInt32 initialCount)
  60 {
  61     APIRET rc;
  62     oslSemaphoreImpl * pSemaphoreImpl;
  63
  64     /* alloc mem. for our internal data structure */
  65     pSemaphoreImpl = (oslSemaphoreImpl *) malloc(sizeof(oslSemaphoreImpl));
  66     if( pSemaphoreImpl == NULL )
  67         return NULL;
  68
  69     /* create semaphore */
  70     rc = DosCreateEventSem( NULL,
  71                             &pSemaphoreImpl->hevReachedZero,
  72                             DC_SEM_SHARED,
  73                             FALSE );
  74     if( rc != NO_ERROR )
  75     {
  76         free( pSemaphoreImpl );
  77         return NULL;
  78     }
  79
  80     pSemaphoreImpl->nCount = initialCount;
  81
  82     // create static mutex for private members
  83     if (MutexLock == NULL)
  84         DosCreateMutexSem( NULL, &MutexLock, 0, FALSE );
  85
  86     return (oslSemaphore) pSemaphoreImpl;
  87 }
  88
  89 /*****************************************************************************/
  90 /* osl_destroySemaphore */
  91 /*****************************************************************************/
  92
  93 /*
  94 - Semaphore l”schen
  95 */
  96
  97 void SAL_CALL osl_destroySemaphore(oslSemaphore Semaphore)
  98 {
  99     oslSemaphoreImpl* pSemaphoreImpl = (oslSemaphoreImpl*)Semaphore;
 100     OSL_ASSERT(Semaphore != 0);
 101
 102     DosCloseEventSem( pSemaphoreImpl->hevReachedZero );
 103
 104     free( pSemaphoreImpl );
 105 }
 106
 107 /*****************************************************************************/
 108 /* osl_acquireSemaphore */
 109 /*****************************************************************************/
 110 /*
 111 - Z„hler -1
 112 - wenn Z„hler < 0: blockieren
 113 */
 114
 115 sal_Bool SAL_CALL osl_acquireSemaphore(oslSemaphore Semaphore)
 116 {
 117     APIRET rc;
 118     oslSemaphoreImpl* pSemaphoreImpl = (oslSemaphoreImpl*)Semaphore;
 119     int nCount;
 120     OSL_ASSERT(Semaphore != 0);
 121
 122     DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 123
 124     while( pSemaphoreImpl->nCount < 1 )
 125     {
 126         sal_uInt32 nPostCount;
 127
 128         DosReleaseMutexSem( MutexLock);
 129
 130         rc = DosWaitEventSem(pSemaphoreImpl->hevReachedZero, SEM_INDEFINITE_WAIT );
 131         DosResetEventSem(pSemaphoreImpl->hevReachedZero, &nPostCount);
 132
 133         DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 134     }
 135
 136     pSemaphoreImpl->nCount--;
 137     DosReleaseMutexSem( MutexLock);
 138
 139     return( rc == NO_ERROR );
 140 }
 141
 142 /*****************************************************************************/
 143 /* osl_tryToAcquireSemaphore */
 144 /*****************************************************************************/
 145 /*
 146 - Z„hler -1, wenn vorher > 0
 147 - wenn Z„hler < 0: mit FALSE zurueck
 148 */
 149 sal_Bool SAL_CALL osl_tryToAcquireSemaphore(oslSemaphore Semaphore)
 150 {
 151     APIRET rc;
 152     oslSemaphoreImpl* pSemaphoreImpl = (oslSemaphoreImpl*)Semaphore;
 153     int nCount;
 154     OSL_ASSERT(Semaphore != 0);
 155
 156     DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 157
 158     nCount = pSemaphoreImpl->nCount;
 159     if( pSemaphoreImpl->nCount > 0 )
 160         pSemaphoreImpl->nCount--;
 161
 162     DosReleaseMutexSem( MutexLock);
 163
 164     return( nCount > 0 );
 165 }
 166
 167 /*****************************************************************************/
 168 /* osl_releaseSemaphore */
 169 /*****************************************************************************/
 170 /*
 171 - Z„hler +1
 172 */
 173 sal_Bool SAL_CALL osl_releaseSemaphore(oslSemaphore Semaphore)
 174 {
 175     APIRET rc;
 176     oslSemaphoreImpl* pSemaphoreImpl = (oslSemaphoreImpl*)Semaphore;
 177     int nCount;
 178     OSL_ASSERT(Semaphore != 0);
 179
 180     DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 181
 182     nCount = pSemaphoreImpl->nCount;
 183     pSemaphoreImpl->nCount++;
 184
 185     DosReleaseMutexSem( MutexLock);
 186
 187     if( nCount == 0 )
 188         DosPostEventSem(pSemaphoreImpl->hevReachedZero);
 189
 190     return( rc == NO_ERROR );
 191 }
 192
 193