git.oblomov.eu Git - wine/blob - dlls/ntdll/sync.c

   1 /*
   2  *      Process synchronisation
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <time.h>
   9 #include "debugtools.h"
  10
  11 #include "winerror.h"
  12 #include "wine/unicode.h"
  13 #include "server.h"
  14 #include "ntddk.h"
  15 #include "ntdll_misc.h"
  16
  17 DEFAULT_DEBUG_CHANNEL(ntdll);
  18
  19
  20 /*
  21  *      Semaphores
  22  */
  23
  24 /******************************************************************************
  25  *  NtCreateSemaphore
  26  */
  27 NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
  28                                    IN ACCESS_MASK access,
  29                                    IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
  30                                    IN ULONG InitialCount,
  31                                    IN ULONG MaximumCount )
  32 {
  33     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
  34     NTSTATUS ret;
  35
  36     if ((MaximumCount <= 0) || (InitialCount < 0) || (InitialCount > MaximumCount))
  37         return STATUS_INVALID_PARAMETER;
  38
  39     *SemaphoreHandle = 0;
  40
  41     SERVER_START_REQ
  42     {
  43         struct create_semaphore_request *req = server_alloc_req( sizeof(*req), len );
  44         req->initial = InitialCount;
  45         req->max     = MaximumCount;
  46         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
  47         if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
  48         if (!(ret = server_call_noerr( REQ_CREATE_SEMAPHORE )))
  49             *SemaphoreHandle = req->handle;
  50     }
  51     SERVER_END_REQ;
  52     return ret;
  53 }
  54
  55 /******************************************************************************
  56  *  NtOpenSemaphore
  57  */
  58 NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
  59                                  IN ACCESS_MASK access,
  60                                  IN const OBJECT_ATTRIBUTES *attr )
  61 {
  62     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
  63     NTSTATUS ret;
  64
  65     *SemaphoreHandle = 0;
  66
  67     SERVER_START_REQ
  68     {
  69         struct open_semaphore_request *req = server_alloc_req( sizeof(*req), len );
  70         req->access  = access;
  71         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
  72         if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
  73         if (!(ret = server_call_noerr( REQ_OPEN_SEMAPHORE )))
  74             *SemaphoreHandle = req->handle;
  75     }
  76     SERVER_END_REQ;
  77     return ret;
  78 }
  79
  80 /******************************************************************************
  81  *  NtQuerySemaphore
  82  */
  83 NTSTATUS WINAPI NtQuerySemaphore(
  84         HANDLE SemaphoreHandle,
  85         PVOID SemaphoreInformationClass,
  86         OUT PVOID SemaphoreInformation,
  87         ULONG Length,
  88         PULONG ReturnLength)
  89 {
  90         FIXME("(0x%08x,%p,%p,0x%08lx,%p) stub!\n",
  91         SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
  92         return STATUS_SUCCESS;
  93 }
  94
  95 /******************************************************************************
  96  *  NtReleaseSemaphore
  97  */
  98 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
  99 {
 100     NTSTATUS ret;
 101     SERVER_START_REQ
 102     {
 103         struct release_semaphore_request *req = server_alloc_req( sizeof(*req), 0 );
 104         req->handle = handle;
 105         req->count  = count;
 106         if (!(ret = server_call_noerr( REQ_RELEASE_SEMAPHORE )))
 107         {
 108             if (previous) *previous = req->prev_count;
 109         }
 110     }
 111     SERVER_END_REQ;
 112     return ret;
 113 }
 114
 115 /*
 116  *      Events
 117  */
 118
 119 /**************************************************************************
 120  * NtCreateEvent
 121  */
 122 NTSTATUS WINAPI NtCreateEvent(
 123         OUT PHANDLE EventHandle,
 124         IN ACCESS_MASK DesiredAccess,
 125         IN const OBJECT_ATTRIBUTES *attr,
 126         IN BOOLEAN ManualReset,
 127         IN BOOLEAN InitialState)
 128 {
 129     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 130     NTSTATUS ret;
 131
 132     *EventHandle = 0;
 133
 134     SERVER_START_REQ
 135     {
 136         struct create_event_request *req = server_alloc_req( sizeof(*req), len );
 137         req->manual_reset = ManualReset;
 138         req->initial_state = InitialState;
 139         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 140         if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
 141         if (!(ret = server_call_noerr( REQ_CREATE_EVENT ))) *EventHandle = req->handle;
 142     }
 143     SERVER_END_REQ;
 144     return ret;
 145 }
 146
 147 /******************************************************************************
 148  *  NtOpenEvent
 149  */
 150 NTSTATUS WINAPI NtOpenEvent(
 151         OUT PHANDLE EventHandle,
 152         IN ACCESS_MASK DesiredAccess,
 153         IN const OBJECT_ATTRIBUTES *attr )
 154 {
 155     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 156     NTSTATUS ret;
 157
 158     *EventHandle = 0;
 159
 160     SERVER_START_REQ
 161     {
 162         struct open_event_request *req = server_alloc_req( sizeof(*req), len );
 163
 164         req->access  = DesiredAccess;
 165         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 166         if (len) memcpy( server_data_ptr(req), attr->ObjectName->Buffer, len );
 167         if (!(ret = server_call_noerr( REQ_OPEN_EVENT ))) *EventHandle = req->handle;
 168     }
 169     SERVER_END_REQ;
 170     return ret;
 171 }
 172
 173
 174 /******************************************************************************
 175  *  NtSetEvent
 176  */
 177 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 178 {
 179     NTSTATUS ret;
 180
 181     /* FIXME: set NumberOfThreadsReleased */
 182
 183     SERVER_START_REQ
 184     {
 185         struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
 186         req->handle = handle;
 187         req->op     = SET_EVENT;
 188         ret = server_call_noerr( REQ_EVENT_OP );
 189     }
 190     SERVER_END_REQ;
 191     return ret;
 192 }
 193
 194 /******************************************************************************
 195  *  NtResetEvent
 196  */
 197 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 198 {
 199     NTSTATUS ret;
 200
 201     /* resetting an event can't release any thread... */
 202     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
 203
 204     SERVER_START_REQ
 205     {
 206         struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
 207         req->handle = handle;
 208         req->op     = RESET_EVENT;
 209         ret = server_call_noerr( REQ_EVENT_OP );
 210     }
 211     SERVER_END_REQ;
 212     return ret;
 213 }
 214
 215 /******************************************************************************
 216  *  NtClearEvent
 217  *
 218  * FIXME
 219  *   same as NtResetEvent ???
 220  */
 221 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 222 {
 223     return NtResetEvent( handle, NULL );
 224 }
 225
 226 /******************************************************************************
 227  *  NtPulseEvent
 228  *
 229  * FIXME
 230  *   PulseCount
 231  */
 232 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 233 {
 234     NTSTATUS ret;
 235     FIXME("(0x%08x,%p)\n", handle, PulseCount);
 236     SERVER_START_REQ
 237     {
 238         struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
 239         req->handle = handle;
 240         req->op     = PULSE_EVENT;
 241         ret = server_call_noerr( REQ_EVENT_OP );
 242     }
 243     SERVER_END_REQ;
 244     return ret;
 245 }
 246
 247 /******************************************************************************
 248  *  NtQueryEvent
 249  */
 250 NTSTATUS WINAPI NtQueryEvent (
 251         IN  HANDLE EventHandle,
 252         IN  UINT EventInformationClass,
 253         OUT PVOID EventInformation,
 254         IN  ULONG EventInformationLength,
 255         OUT PULONG  ReturnLength)
 256 {
 257         FIXME("(0x%08x)\n", EventHandle);
 258         return STATUS_SUCCESS;
 259 }