Utilities/cmlibuv/src/win/thread.c

   1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to
   5  * deal in the Software without restriction, including without limitation the
   6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   7  * sell copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  19  * IN THE SOFTWARE.
  20  */
  21
  22 #include <assert.h>
  23 #include <limits.h>
  24 #include <stdlib.h>
  25
  26 #if defined(__MINGW64_VERSION_MAJOR)
  27 /* MemoryBarrier expands to __mm_mfence in some cases (x86+sse2), which may
  28  * require this header in some versions of mingw64. */
  29 #include <intrin.h>
  30 #endif
  31
  32 #include "uv.h"
  33 #include "internal.h"
  34
  35 static void uv__once_inner(uv_once_t* guard, void (*callback)(void)) {
  36   DWORD result;
  37   HANDLE existing_event, created_event;
  38
  39   created_event = CreateEvent(NULL, 1, 0, NULL);
  40   if (created_event == 0) {
  41     /* Could fail in a low-memory situation? */
  42     uv_fatal_error(GetLastError(), "CreateEvent");
  43   }
  44
  45   existing_event = InterlockedCompareExchangePointer(&guard->event,
  46                                                      created_event,
  47                                                      NULL);
  48
  49   if (existing_event == NULL) {
  50     /* We won the race */
  51     callback();
  52
  53     result = SetEvent(created_event);
  54     assert(result);
  55     guard->ran = 1;
  56
  57   } else {
  58     /* We lost the race. Destroy the event we created and wait for the existing
  59      * one to become signaled. */
  60     CloseHandle(created_event);
  61     result = WaitForSingleObject(existing_event, INFINITE);
  62     assert(result == WAIT_OBJECT_0);
  63   }
  64 }
  65
  66
  67 void uv_once(uv_once_t* guard, void (*callback)(void)) {
  68   /* Fast case - avoid WaitForSingleObject. */
  69   if (guard->ran) {
  70     return;
  71   }
  72
  73   uv__once_inner(guard, callback);
  74 }
  75
  76
  77 /* Verify that uv_thread_t can be stored in a TLS slot. */
  78 STATIC_ASSERT(sizeof(uv_thread_t) <= sizeof(void*));
  79
  80 static uv_key_t uv__current_thread_key;
  81 static uv_once_t uv__current_thread_init_guard = UV_ONCE_INIT;
  82
  83
  84 static void uv__init_current_thread_key(void) {
  85   if (uv_key_create(&uv__current_thread_key))
  86     abort();
  87 }
  88
  89
  90 struct thread_ctx {
  91   void (*entry)(void* arg);
  92   void* arg;
  93   uv_thread_t self;
  94 };
  95
  96
  97 static UINT __stdcall uv__thread_start(void* arg) {
  98   struct thread_ctx *ctx_p;
  99   struct thread_ctx ctx;
 100
 101   ctx_p = arg;
 102   ctx = *ctx_p;
 103   uv__free(ctx_p);
 104
 105   uv_once(&uv__current_thread_init_guard, uv__init_current_thread_key);
 106   uv_key_set(&uv__current_thread_key, ctx.self);
 107
 108   ctx.entry(ctx.arg);
 109
 110   return 0;
 111 }
 112
 113
 114 int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
 115   uv_thread_options_t params;
 116   params.flags = UV_THREAD_NO_FLAGS;
 117   return uv_thread_create_ex(tid, &params, entry, arg);
 118 }
 119
 120 int uv_thread_create_ex(uv_thread_t* tid,
 121                         const uv_thread_options_t* params,
 122                         void (*entry)(void *arg),
 123                         void *arg) {
 124   struct thread_ctx* ctx;
 125   int err;
 126   HANDLE thread;
 127   SYSTEM_INFO sysinfo;
 128   size_t stack_size;
 129   size_t pagesize;
 130
 131   stack_size =
 132       params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
 133
 134   if (stack_size != 0) {
 135     GetNativeSystemInfo(&sysinfo);
 136     pagesize = (size_t)sysinfo.dwPageSize;
 137     /* Round up to the nearest page boundary. */
 138     stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
 139
 140     if ((unsigned)stack_size != stack_size)
 141       return UV_EINVAL;
 142   }
 143
 144   ctx = uv__malloc(sizeof(*ctx));
 145   if (ctx == NULL)
 146     return UV_ENOMEM;
 147
 148   ctx->entry = entry;
 149   ctx->arg = arg;
 150
 151   /* Create the thread in suspended state so we have a chance to pass
 152    * its own creation handle to it */
 153   thread = (HANDLE) _beginthreadex(NULL,
 154                                    (unsigned)stack_size,
 155                                    uv__thread_start,
 156                                    ctx,
 157                                    CREATE_SUSPENDED,
 158                                    NULL);
 159   if (thread == NULL) {
 160     err = errno;
 161     uv__free(ctx);
 162   } else {
 163     err = 0;
 164     *tid = thread;
 165     ctx->self = thread;
 166     ResumeThread(thread);
 167   }
 168
 169   switch (err) {
 170     case 0:
 171       return 0;
 172     case EACCES:
 173       return UV_EACCES;
 174     case EAGAIN:
 175       return UV_EAGAIN;
 176     case EINVAL:
 177       return UV_EINVAL;
 178   }
 179
 180   return UV_EIO;
 181 }
 182
 183
 184 uv_thread_t uv_thread_self(void) {
 185   uv_thread_t key;
 186   uv_once(&uv__current_thread_init_guard, uv__init_current_thread_key);
 187   key = uv_key_get(&uv__current_thread_key);
 188   if (key == NULL) {
 189       /* If the thread wasn't started by uv_thread_create (such as the main
 190        * thread), we assign an id to it now. */
 191       if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
 192                            GetCurrentProcess(), &key, 0,
 193                            FALSE, DUPLICATE_SAME_ACCESS)) {
 194           uv_fatal_error(GetLastError(), "DuplicateHandle");
 195       }
 196       uv_key_set(&uv__current_thread_key, key);
 197   }
 198   return key;
 199 }
 200
 201
 202 int uv_thread_join(uv_thread_t *tid) {
 203   if (WaitForSingleObject(*tid, INFINITE))
 204     return uv_translate_sys_error(GetLastError());
 205   else {
 206     CloseHandle(*tid);
 207     *tid = 0;
 208     MemoryBarrier();  /* For feature parity with pthread_join(). */
 209     return 0;
 210   }
 211 }
 212
 213
 214 int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2) {
 215   return *t1 == *t2;
 216 }
 217
 218
 219 int uv_mutex_init(uv_mutex_t* mutex) {
 220   InitializeCriticalSection(mutex);
 221   return 0;
 222 }
 223
 224
 225 int uv_mutex_init_recursive(uv_mutex_t* mutex) {
 226   return uv_mutex_init(mutex);
 227 }
 228
 229
 230 void uv_mutex_destroy(uv_mutex_t* mutex) {
 231   DeleteCriticalSection(mutex);
 232 }
 233
 234
 235 void uv_mutex_lock(uv_mutex_t* mutex) {
 236   EnterCriticalSection(mutex);
 237 }
 238
 239
 240 int uv_mutex_trylock(uv_mutex_t* mutex) {
 241   if (TryEnterCriticalSection(mutex))
 242     return 0;
 243   else
 244     return UV_EBUSY;
 245 }
 246
 247
 248 void uv_mutex_unlock(uv_mutex_t* mutex) {
 249   LeaveCriticalSection(mutex);
 250 }
 251
 252 /* Ensure that the ABI for this type remains stable in v1.x */
 253 #ifdef _WIN64
 254 STATIC_ASSERT(sizeof(uv_rwlock_t) == 80);
 255 #else
 256 STATIC_ASSERT(sizeof(uv_rwlock_t) == 48);
 257 #endif
 258
 259 int uv_rwlock_init(uv_rwlock_t* rwlock) {
 260   memset(rwlock, 0, sizeof(*rwlock));
 261   InitializeSRWLock(&rwlock->read_write_lock_);
 262
 263   return 0;
 264 }
 265
 266
 267 void uv_rwlock_destroy(uv_rwlock_t* rwlock) {
 268   /* SRWLock does not need explicit destruction so long as there are no waiting threads
 269      See: https://docs.microsoft.com/windows/win32/api/synchapi/nf-synchapi-initializesrwlock#remarks */
 270 }
 271
 272
 273 void uv_rwlock_rdlock(uv_rwlock_t* rwlock) {
 274   AcquireSRWLockShared(&rwlock->read_write_lock_);
 275 }
 276
 277
 278 int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
 279   if (!TryAcquireSRWLockShared(&rwlock->read_write_lock_))
 280     return UV_EBUSY;
 281
 282   return 0;
 283 }
 284
 285
 286 void uv_rwlock_rdunlock(uv_rwlock_t* rwlock) {
 287   ReleaseSRWLockShared(&rwlock->read_write_lock_);
 288 }
 289
 290
 291 void uv_rwlock_wrlock(uv_rwlock_t* rwlock) {
 292   AcquireSRWLockExclusive(&rwlock->read_write_lock_);
 293 }
 294
 295
 296 int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
 297   if (!TryAcquireSRWLockExclusive(&rwlock->read_write_lock_))
 298     return UV_EBUSY;
 299
 300   return 0;
 301 }
 302
 303
 304 void uv_rwlock_wrunlock(uv_rwlock_t* rwlock) {
 305   ReleaseSRWLockExclusive(&rwlock->read_write_lock_);
 306 }
 307
 308
 309 int uv_sem_init(uv_sem_t* sem, unsigned int value) {
 310   *sem = CreateSemaphore(NULL, value, INT_MAX, NULL);
 311   if (*sem == NULL)
 312     return uv_translate_sys_error(GetLastError());
 313   else
 314     return 0;
 315 }
 316
 317
 318 void uv_sem_destroy(uv_sem_t* sem) {
 319   if (!CloseHandle(*sem))
 320     abort();
 321 }
 322
 323
 324 void uv_sem_post(uv_sem_t* sem) {
 325   if (!ReleaseSemaphore(*sem, 1, NULL))
 326     abort();
 327 }
 328
 329
 330 void uv_sem_wait(uv_sem_t* sem) {
 331   if (WaitForSingleObject(*sem, INFINITE) != WAIT_OBJECT_0)
 332     abort();
 333 }
 334
 335
 336 int uv_sem_trywait(uv_sem_t* sem) {
 337   DWORD r = WaitForSingleObject(*sem, 0);
 338
 339   if (r == WAIT_OBJECT_0)
 340     return 0;
 341
 342   if (r == WAIT_TIMEOUT)
 343     return UV_EAGAIN;
 344
 345   abort();
 346   return -1; /* Satisfy the compiler. */
 347 }
 348
 349
 350 int uv_cond_init(uv_cond_t* cond) {
 351   InitializeConditionVariable(&cond->cond_var);
 352   return 0;
 353 }
 354
 355
 356 void uv_cond_destroy(uv_cond_t* cond) {
 357   /* nothing to do */
 358   (void) &cond;
 359 }
 360
 361
 362 void uv_cond_signal(uv_cond_t* cond) {
 363   WakeConditionVariable(&cond->cond_var);
 364 }
 365
 366
 367 void uv_cond_broadcast(uv_cond_t* cond) {
 368   WakeAllConditionVariable(&cond->cond_var);
 369 }
 370
 371
 372 void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) {
 373   if (!SleepConditionVariableCS(&cond->cond_var, mutex, INFINITE))
 374     abort();
 375 }
 376
 377 int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) {
 378   if (SleepConditionVariableCS(&cond->cond_var, mutex, (DWORD)(timeout / 1e6)))
 379     return 0;
 380   if (GetLastError() != ERROR_TIMEOUT)
 381     abort();
 382   return UV_ETIMEDOUT;
 383 }
 384
 385
 386 int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {
 387   int err;
 388
 389   barrier->n = count;
 390   barrier->count = 0;
 391
 392   err = uv_mutex_init(&barrier->mutex);
 393   if (err)
 394     return err;
 395
 396   err = uv_sem_init(&barrier->turnstile1, 0);
 397   if (err)
 398     goto error2;
 399
 400   err = uv_sem_init(&barrier->turnstile2, 1);
 401   if (err)
 402     goto error;
 403
 404   return 0;
 405
 406 error:
 407   uv_sem_destroy(&barrier->turnstile1);
 408 error2:
 409   uv_mutex_destroy(&barrier->mutex);
 410   return err;
 411
 412 }
 413
 414
 415 void uv_barrier_destroy(uv_barrier_t* barrier) {
 416   uv_sem_destroy(&barrier->turnstile2);
 417   uv_sem_destroy(&barrier->turnstile1);
 418   uv_mutex_destroy(&barrier->mutex);
 419 }
 420
 421
 422 int uv_barrier_wait(uv_barrier_t* barrier) {
 423   int serial_thread;
 424
 425   uv_mutex_lock(&barrier->mutex);
 426   if (++barrier->count == barrier->n) {
 427     uv_sem_wait(&barrier->turnstile2);
 428     uv_sem_post(&barrier->turnstile1);
 429   }
 430   uv_mutex_unlock(&barrier->mutex);
 431
 432   uv_sem_wait(&barrier->turnstile1);
 433   uv_sem_post(&barrier->turnstile1);
 434
 435   uv_mutex_lock(&barrier->mutex);
 436   serial_thread = (--barrier->count == 0);
 437   if (serial_thread) {
 438     uv_sem_wait(&barrier->turnstile1);
 439     uv_sem_post(&barrier->turnstile2);
 440   }
 441   uv_mutex_unlock(&barrier->mutex);
 442
 443   uv_sem_wait(&barrier->turnstile2);
 444   uv_sem_post(&barrier->turnstile2);
 445   return serial_thread;
 446 }
 447
 448
 449 int uv_key_create(uv_key_t* key) {
 450   key->tls_index = TlsAlloc();
 451   if (key->tls_index == TLS_OUT_OF_INDEXES)
 452     return UV_ENOMEM;
 453   return 0;
 454 }
 455
 456
 457 void uv_key_delete(uv_key_t* key) {
 458   if (TlsFree(key->tls_index) == FALSE)
 459     abort();
 460   key->tls_index = TLS_OUT_OF_INDEXES;
 461 }
 462
 463
 464 void* uv_key_get(uv_key_t* key) {
 465   void* value;
 466
 467   value = TlsGetValue(key->tls_index);
 468   if (value == NULL)
 469     if (GetLastError() != ERROR_SUCCESS)
 470       abort();
 471
 472   return value;
 473 }
 474
 475
 476 void uv_key_set(uv_key_t* key, void* value) {
 477   if (TlsSetValue(key->tls_index, value) == FALSE)
 478     abort();
 479 }