scheduler/semaphore.c

   1 /*
   2  * Win32 semaphores
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include "winerror.h"
   9 #include "k32obj.h"
  10 #include "process.h"
  11 #include "thread.h"
  12 #include "heap.h"
  13 #include "server/request.h"
  14 #include "server.h"
  15
  16 typedef struct
  17 {
  18     K32OBJ        header;
  19 } SEMAPHORE;
  20
  21
  22 /***********************************************************************
  23  *           CreateSemaphore32A   (KERNEL32.174)
  24  */
  25 HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial,
  26                                     LONG max, LPCSTR name )
  27 {
  28     struct create_semaphore_request req;
  29     struct create_semaphore_reply reply;
  30     int len = name ? strlen(name) + 1 : 0;
  31     HANDLE handle;
  32     SEMAPHORE *sem;
  33
  34     /* Check parameters */
  35
  36     if ((max <= 0) || (initial < 0) || (initial > max))
  37     {
  38         SetLastError( ERROR_INVALID_PARAMETER );
  39         return 0;
  40     }
  41
  42     req.initial = (unsigned int)initial;
  43     req.max     = (unsigned int)max;
  44     req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  45
  46     CLIENT_SendRequest( REQ_CREATE_SEMAPHORE, -1, 2, &req, sizeof(req), name, len );
  47     CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
  48     if (reply.handle == -1) return 0;
  49
  50     SYSTEM_LOCK();
  51     sem = (SEMAPHORE *)K32OBJ_Create( K32OBJ_SEMAPHORE, sizeof(*sem),
  52                                       name, reply.handle, SEMAPHORE_ALL_ACCESS,
  53                                       sa, &handle);
  54     if (sem) K32OBJ_DecCount( &sem->header );
  55     SYSTEM_UNLOCK();
  56     if (handle == INVALID_HANDLE_VALUE) handle = 0;
  57     return handle;
  58 }
  59
  60
  61 /***********************************************************************
  62  *           CreateSemaphore32W   (KERNEL32.175)
  63  */
  64 HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
  65                                     LONG max, LPCWSTR name )
  66 {
  67     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
  68     HANDLE ret = CreateSemaphoreA( sa, initial, max, nameA );
  69     if (nameA) HeapFree( GetProcessHeap(), 0, nameA );
  70     return ret;
  71 }
  72
  73
  74 /***********************************************************************
  75  *           OpenSemaphore32A   (KERNEL32.545)
  76  */
  77 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
  78 {
  79     HANDLE handle = 0;
  80     K32OBJ *obj;
  81     struct open_named_obj_request req;
  82     struct open_named_obj_reply reply;
  83     int len = name ? strlen(name) + 1 : 0;
  84
  85     req.type    = OPEN_SEMAPHORE;
  86     req.access  = access;
  87     req.inherit = inherit;
  88     CLIENT_SendRequest( REQ_OPEN_NAMED_OBJ, -1, 2, &req, sizeof(req), name, len );
  89     CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
  90     if (reply.handle != -1)
  91     {
  92         SYSTEM_LOCK();
  93         if ((obj = K32OBJ_FindNameType( name, K32OBJ_SEMAPHORE )) != NULL)
  94         {
  95             handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, reply.handle );
  96             K32OBJ_DecCount( obj );
  97             if (handle == INVALID_HANDLE_VALUE)
  98                 handle = 0; /* must return 0 on failure, not -1 */
  99         }
 100         else CLIENT_CloseHandle( reply.handle );
 101         SYSTEM_UNLOCK();
 102     }
 103     return handle;
 104 }
 105
 106
 107 /***********************************************************************
 108  *           OpenSemaphore32W   (KERNEL32.546)
 109  */
 110 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 111 {
 112     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 113     HANDLE ret = OpenSemaphoreA( access, inherit, nameA );
 114     if (nameA) HeapFree( GetProcessHeap(), 0, nameA );
 115     return ret;
 116 }
 117
 118
 119 /***********************************************************************
 120  *           ReleaseSemaphore   (KERNEL32.583)
 121  */
 122 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 123 {
 124     struct release_semaphore_request req;
 125     struct release_semaphore_reply reply;
 126
 127     if (count < 0)
 128     {
 129         SetLastError( ERROR_INVALID_PARAMETER );
 130         return FALSE;
 131     }
 132     req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
 133                                          K32OBJ_SEMAPHORE, SEMAPHORE_MODIFY_STATE );
 134     if (req.handle == -1) return FALSE;
 135     req.count = (unsigned int)count;
 136     CLIENT_SendRequest( REQ_RELEASE_SEMAPHORE, -1, 1, &req, sizeof(req) );
 137     if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
 138     if (previous) *previous = reply.prev_count;
 139     return TRUE;
 140 }