mono/io-layer/wait.c

   1 /*
   2  * wait.c:  wait for handles to become signalled
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * (C) 2002 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <string.h>
  13 #include <errno.h>
  14
  15 #include <mono/os/gc_wrapper.h>
  16
  17 #include <mono/io-layer/wapi.h>
  18 #include <mono/io-layer/handles-private.h>
  19 #include <mono/io-layer/wapi-private.h>
  20 #include <mono/io-layer/mono-mutex.h>
  21 #include <mono/io-layer/misc-private.h>
  22
  23 #undef DEBUG
  24
  25 /**
  26  * WaitForSingleObjectEx:
  27  * @handle: an object to wait for
  28  * @timeout: the maximum time in milliseconds to wait for
  29  * @alertable: if TRUE, the wait can be interrupted by an APC call
  30  *
  31  * This function returns when either @handle is signalled, or @timeout
  32  * ms elapses.  If @timeout is zero, the object's state is tested and
  33  * the function returns immediately.  If @timeout is %INFINITE, the
  34  * function waits forever.
  35  *
  36  * Return value: %WAIT_ABANDONED - @handle is a mutex that was not
  37  * released by the owning thread when it exited.  Ownership of the
  38  * mutex object is granted to the calling thread and the mutex is set
  39  * to nonsignalled.  %WAIT_OBJECT_0 - The state of @handle is
  40  * signalled.  %WAIT_TIMEOUT - The @timeout interval elapsed and
  41  * @handle's state is still not signalled.  %WAIT_FAILED - an error
  42  * occurred. %WAIT_IO_COMPLETION - the wait was ended by an APC.
  43  */
  44 guint32 WaitForSingleObjectEx(gpointer handle, guint32 timeout,
  45                                                 gboolean alertable)
  46 {
  47         guint32 ret, waited;
  48         struct timespec abstime;
  49         int thr_ret;
  50         gboolean apc_pending = FALSE;
  51         gpointer current_thread = GetCurrentThread ();
  52
  53         if(_wapi_handle_test_capabilities (handle,
  54                                            WAPI_HANDLE_CAP_WAIT)==FALSE) {
  55 #ifdef DEBUG
  56                 g_message (G_GNUC_PRETTY_FUNCTION
  57                            ": handle %p can't be waited for", handle);
  58 #endif
  59
  60                 return(WAIT_FAILED);
  61         }
  62
  63 #ifdef DEBUG
  64         g_message (G_GNUC_PRETTY_FUNCTION ": locking handle %p", handle);
  65 #endif
  66
  67         pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
  68                               handle);
  69         thr_ret = _wapi_handle_lock_handle (handle);
  70         g_assert (thr_ret == 0);
  71
  72         if(_wapi_handle_test_capabilities (handle,
  73                                            WAPI_HANDLE_CAP_OWN)==TRUE) {
  74                 if(_wapi_handle_ops_isowned (handle)==TRUE) {
  75 #ifdef DEBUG
  76                         g_message (G_GNUC_PRETTY_FUNCTION
  77                                    ": handle %p already owned", handle);
  78 #endif
  79                         _wapi_handle_ops_own (handle);
  80                         ret=WAIT_OBJECT_0;
  81                         goto done;
  82                 }
  83         }
  84
  85         if (alertable && _wapi_thread_apc_pending (current_thread)) {
  86                 apc_pending = TRUE;
  87                 ret = WAIT_IO_COMPLETION;
  88                 goto done;
  89         }
  90
  91         if(_wapi_handle_issignalled (handle)) {
  92 #ifdef DEBUG
  93                 g_message (G_GNUC_PRETTY_FUNCTION
  94                            ": handle %p already signalled", handle);
  95 #endif
  96
  97                 _wapi_handle_ops_own (handle);
  98                 ret=WAIT_OBJECT_0;
  99                 goto done;
 100         }
 101
 102         /* Have to wait for it */
 103         if(timeout!=INFINITE) {
 104                 _wapi_calc_timeout (&abstime, timeout);
 105         }
 106
 107         do {
 108                 if(timeout==INFINITE) {
 109                         waited=_wapi_handle_wait_signal_handle (handle);
 110                 } else {
 111                         waited=_wapi_handle_timedwait_signal_handle (handle,
 112                                                                      &abstime);
 113                 }
 114
 115                 if (alertable)
 116                         apc_pending = _wapi_thread_apc_pending (current_thread);
 117
 118                 if(waited==0 && !apc_pending) {
 119                         /* Condition was signalled, so hopefully
 120                          * handle is signalled now.  (It might not be
 121                          * if someone else got in before us.)
 122                          */
 123                         if(_wapi_handle_issignalled (handle)) {
 124 #ifdef DEBUG
 125                                 g_message (G_GNUC_PRETTY_FUNCTION
 126                                            ": handle %p signalled", handle);
 127 #endif
 128
 129                                 _wapi_handle_ops_own (handle);
 130                                 ret=WAIT_OBJECT_0;
 131                                 goto done;
 132                         }
 133
 134                         /* Better luck next time */
 135                 }
 136         } while(waited==0 && !apc_pending);
 137
 138         /* Timeout or other error */
 139 #ifdef DEBUG
 140         g_message (G_GNUC_PRETTY_FUNCTION ": wait on handle %p error: %s",
 141                    handle, strerror (ret));
 142 #endif
 143
 144         ret=WAIT_TIMEOUT;
 145
 146 done:
 147
 148 #ifdef DEBUG
 149         g_message (G_GNUC_PRETTY_FUNCTION ": unlocking handle %p", handle);
 150 #endif
 151
 152         thr_ret = _wapi_handle_unlock_handle (handle);
 153         g_assert (thr_ret == 0);
 154         pthread_cleanup_pop (0);
 155
 156         if (apc_pending) {
 157                 _wapi_thread_dispatch_apc_queue (current_thread);
 158                 ret = WAIT_IO_COMPLETION;
 159         }
 160
 161         return(ret);
 162 }
 163
 164 guint32 WaitForSingleObject(gpointer handle, guint32 timeout)
 165 {
 166         return WaitForSingleObjectEx (handle, timeout, FALSE);
 167 }
 168
 169
 170 /**
 171  * SignalObjectAndWait:
 172  * @signal_handle: An object to signal
 173  * @wait: An object to wait for
 174  * @timeout: The maximum time in milliseconds to wait for
 175  * @alertable: Specifies whether the function returnes when the system
 176  * queues an I/O completion routine or an APC for the calling thread.
 177  *
 178  * Atomically signals @signal and waits for @wait to become signalled,
 179  * or @timeout ms elapses.  If @timeout is zero, the object's state is
 180  * tested and the function returns immediately.  If @timeout is
 181  * %INFINITE, the function waits forever.
 182  *
 183  * @signal can be a semaphore, mutex or event object.
 184  *
 185  * If @alertable is %TRUE and the system queues an I/O completion
 186  * routine or an APC for the calling thread, the function returns and
 187  * the thread calls the completion routine or APC function.  If
 188  * %FALSE, the function does not return, and the thread does not call
 189  * the completion routine or APC function.  A completion routine is
 190  * queued when the ReadFileEx() or WriteFileEx() function in which it
 191  * was specified has completed.  The calling thread is the thread that
 192  * initiated the read or write operation.  An APC is queued when
 193  * QueueUserAPC() is called.  Currently completion routines and APC
 194  * functions are not supported.
 195  *
 196  * Return value: %WAIT_ABANDONED - @wait is a mutex that was not
 197  * released by the owning thread when it exited.  Ownershop of the
 198  * mutex object is granted to the calling thread and the mutex is set
 199  * to nonsignalled.  %WAIT_IO_COMPLETION - the wait was ended by one
 200  * or more user-mode asynchronous procedure calls queued to the
 201  * thread.  %WAIT_OBJECT_0 - The state of @wait is signalled.
 202  * %WAIT_TIMEOUT - The @timeout interval elapsed and @wait's state is
 203  * still not signalled.  %WAIT_FAILED - an error occurred.
 204  */
 205 guint32 SignalObjectAndWait(gpointer signal_handle, gpointer wait,
 206                             guint32 timeout, gboolean alertable)
 207 {
 208         guint32 ret, waited;
 209         struct timespec abstime;
 210         int thr_ret;
 211         gboolean apc_pending = FALSE;
 212         gpointer current_thread = GetCurrentThread ();
 213
 214         if(_wapi_handle_test_capabilities (signal_handle,
 215                                            WAPI_HANDLE_CAP_SIGNAL)==FALSE) {
 216                 return(WAIT_FAILED);
 217         }
 218
 219         if(_wapi_handle_test_capabilities (wait,
 220                                            WAPI_HANDLE_CAP_WAIT)==FALSE) {
 221                 return(WAIT_FAILED);
 222         }
 223
 224 #ifdef DEBUG
 225         g_message (G_GNUC_PRETTY_FUNCTION ": locking handle %p", wait);
 226 #endif
 227
 228         pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
 229                               wait);
 230         thr_ret = _wapi_handle_lock_handle (wait);
 231         g_assert (thr_ret == 0);
 232
 233         _wapi_handle_ops_signal (signal_handle);
 234
 235         if(_wapi_handle_test_capabilities (wait, WAPI_HANDLE_CAP_OWN)==TRUE) {
 236                 if(_wapi_handle_ops_isowned (wait)==TRUE) {
 237 #ifdef DEBUG
 238                         g_message (G_GNUC_PRETTY_FUNCTION
 239                                    ": handle %p already owned", wait);
 240 #endif
 241                         _wapi_handle_ops_own (wait);
 242                         ret=WAIT_OBJECT_0;
 243                         goto done;
 244                 }
 245         }
 246
 247         if (alertable && _wapi_thread_apc_pending (current_thread)) {
 248                 apc_pending = TRUE;
 249                 ret = WAIT_IO_COMPLETION;
 250                 goto done;
 251         }
 252
 253         if(_wapi_handle_issignalled (wait)) {
 254 #ifdef DEBUG
 255                 g_message (G_GNUC_PRETTY_FUNCTION
 256                            ": handle %p already signalled", wait);
 257 #endif
 258
 259                 _wapi_handle_ops_own (wait);
 260                 ret=WAIT_OBJECT_0;
 261                 goto done;
 262         }
 263
 264         /* Have to wait for it */
 265         if(timeout!=INFINITE) {
 266                 _wapi_calc_timeout (&abstime, timeout);
 267         }
 268
 269         do {
 270                 if(timeout==INFINITE) {
 271                         waited=_wapi_handle_wait_signal_handle (wait);
 272                 } else {
 273                         waited=_wapi_handle_timedwait_signal_handle (wait,
 274                                                                      &abstime);
 275                 }
 276
 277                 if (alertable)
 278                         apc_pending = _wapi_thread_apc_pending (current_thread);
 279
 280                 if(waited==0 && !apc_pending) {
 281                         /* Condition was signalled, so hopefully
 282                          * handle is signalled now.  (It might not be
 283                          * if someone else got in before us.)
 284                          */
 285                         if(_wapi_handle_issignalled (wait)) {
 286 #ifdef DEBUG
 287                                 g_message (G_GNUC_PRETTY_FUNCTION
 288                                            ": handle %p signalled", wait);
 289 #endif
 290
 291                                 _wapi_handle_ops_own (wait);
 292                                 ret=WAIT_OBJECT_0;
 293                                 goto done;
 294                         }
 295
 296                         /* Better luck next time */
 297                 }
 298         } while(waited==0 && !apc_pending);
 299
 300         /* Timeout or other error */
 301 #ifdef DEBUG
 302         g_message (G_GNUC_PRETTY_FUNCTION ": wait on handle %p error: %s",
 303                    wait, strerror (ret));
 304 #endif
 305
 306         ret=WAIT_TIMEOUT;
 307
 308 done:
 309
 310 #ifdef DEBUG
 311         g_message (G_GNUC_PRETTY_FUNCTION ": unlocking handle %p", wait);
 312 #endif
 313
 314         thr_ret = _wapi_handle_unlock_handle (wait);
 315         g_assert (thr_ret == 0);
 316         pthread_cleanup_pop (0);
 317
 318         if (apc_pending) {
 319                 _wapi_thread_dispatch_apc_queue (current_thread);
 320                 ret = WAIT_IO_COMPLETION;
 321         }
 322
 323         return(ret);
 324 }
 325
 326 struct handle_cleanup_data
 327 {
 328         guint32 numobjects;
 329         gpointer *handles;
 330 };
 331
 332 static void handle_cleanup (void *data)
 333 {
 334         struct handle_cleanup_data *handles = (struct handle_cleanup_data *)data;
 335
 336         _wapi_handle_unlock_handles (handles->numobjects, handles->handles);
 337 }
 338
 339 static gboolean test_and_own (guint32 numobjects, gpointer *handles,
 340                               gboolean waitall, guint32 *count,
 341                               guint32 *lowest)
 342 {
 343         struct handle_cleanup_data cleanup_data;
 344         gboolean done;
 345         int i;
 346
 347 #ifdef DEBUG
 348         g_message (G_GNUC_PRETTY_FUNCTION ": locking handles");
 349 #endif
 350         cleanup_data.numobjects = numobjects;
 351         cleanup_data.handles = handles;
 352
 353         pthread_cleanup_push (handle_cleanup, (void *)&cleanup_data);
 354         done = _wapi_handle_count_signalled_handles (numobjects, handles,
 355                                                      waitall, count, lowest);
 356         if (done == TRUE) {
 357                 for (i = 0; i < numobjects; i++) {
 358                         _wapi_handle_ops_own (handles[i]);
 359                 }
 360         }
 361
 362 #ifdef DEBUG
 363         g_message (G_GNUC_PRETTY_FUNCTION ": unlocking handles");
 364 #endif
 365
 366         /* calls the unlock function */
 367         pthread_cleanup_pop (1);
 368
 369         return(done);
 370 }
 371
 372
 373
 374 /**
 375  * WaitForMultipleObjectsEx:
 376  * @numobjects: The number of objects in @handles. The maximum allowed
 377  * is %MAXIMUM_WAIT_OBJECTS.
 378  * @handles: An array of object handles.  Duplicates are not allowed.
 379  * @waitall: If %TRUE, this function waits until all of the handles
 380  * are signalled.  If %FALSE, this function returns when any object is
 381  * signalled.
 382  * @timeout: The maximum time in milliseconds to wait for.
 383  * @alertable: if TRUE, the wait can be interrupted by an APC call
 384  *
 385  * This function returns when either one or more of @handles is
 386  * signalled, or @timeout ms elapses.  If @timeout is zero, the state
 387  * of each item of @handles is tested and the function returns
 388  * immediately.  If @timeout is %INFINITE, the function waits forever.
 389  *
 390  * Return value: %WAIT_OBJECT_0 to %WAIT_OBJECT_0 + @numobjects - 1 -
 391  * if @waitall is %TRUE, indicates that all objects are signalled.  If
 392  * @waitall is %FALSE, the return value minus %WAIT_OBJECT_0 indicates
 393  * the first index into @handles of the objects that are signalled.
 394  * %WAIT_ABANDONED_0 to %WAIT_ABANDONED_0 + @numobjects - 1 - if
 395  * @waitall is %TRUE, indicates that all objects are signalled, and at
 396  * least one object is an abandoned mutex object (See
 397  * WaitForSingleObject() for a description of abandoned mutexes.)  If
 398  * @waitall is %FALSE, the return value minus %WAIT_ABANDONED_0
 399  * indicates the first index into @handles of an abandoned mutex.
 400  * %WAIT_TIMEOUT - The @timeout interval elapsed and no objects in
 401  * @handles are signalled.  %WAIT_FAILED - an error occurred.
 402  * %WAIT_IO_COMPLETION - the wait was ended by an APC.
 403  */
 404 guint32 WaitForMultipleObjectsEx(guint32 numobjects, gpointer *handles,
 405                                gboolean waitall, guint32 timeout, gboolean alertable)
 406 {
 407         GHashTable *dups;
 408         gboolean duplicate=FALSE, bogustype=FALSE, done;
 409         guint32 count, lowest;
 410         struct timespec abstime;
 411         guint i;
 412         guint32 ret;
 413         int thr_ret;
 414         gpointer current_thread = GetCurrentThread ();
 415
 416         if(numobjects>MAXIMUM_WAIT_OBJECTS) {
 417 #ifdef DEBUG
 418                 g_message(G_GNUC_PRETTY_FUNCTION ": Too many handles: %d",
 419                           numobjects);
 420 #endif
 421
 422                 return(WAIT_FAILED);
 423         }
 424
 425         if (numobjects == 1) {
 426                 return WaitForSingleObjectEx (handles [0], timeout, alertable);
 427         }
 428
 429         /* Check for duplicates */
 430         dups=g_hash_table_new(g_direct_hash, g_direct_equal);
 431         for(i=0; i<numobjects; i++) {
 432                 gpointer exists=g_hash_table_lookup(dups, handles[i]);
 433                 if(exists!=NULL) {
 434 #ifdef DEBUG
 435                         g_message(G_GNUC_PRETTY_FUNCTION
 436                                   ": Handle %p duplicated", handles[i]);
 437 #endif
 438
 439                         duplicate=TRUE;
 440                         break;
 441                 }
 442
 443                 if(_wapi_handle_test_capabilities (handles[i], WAPI_HANDLE_CAP_WAIT)==FALSE) {
 444 #ifdef DEBUG
 445                         g_message (G_GNUC_PRETTY_FUNCTION
 446                                    ": Handle %p can't be waited for",
 447                                    handles[i]);
 448 #endif
 449
 450                         bogustype=TRUE;
 451                 }
 452
 453                 g_hash_table_insert(dups, handles[i], handles[i]);
 454         }
 455         g_hash_table_destroy(dups);
 456
 457         if(duplicate==TRUE) {
 458 #ifdef DEBUG
 459                 g_message(G_GNUC_PRETTY_FUNCTION
 460                           ": Returning due to duplicates");
 461 #endif
 462
 463                 return(WAIT_FAILED);
 464         }
 465
 466         if(bogustype==TRUE) {
 467 #ifdef DEBUG
 468                 g_message(G_GNUC_PRETTY_FUNCTION
 469                           ": Returning due to bogus type");
 470 #endif
 471
 472                 return(WAIT_FAILED);
 473         }
 474
 475         done=test_and_own (numobjects, handles, waitall, &count, &lowest);
 476         if(done==TRUE) {
 477                 return(WAIT_OBJECT_0+lowest);
 478         }
 479
 480         /* Have to wait for some or all handles to become signalled
 481          */
 482
 483         if(timeout!=INFINITE) {
 484                 _wapi_calc_timeout (&abstime, timeout);
 485         }
 486
 487         if (alertable && _wapi_thread_apc_pending (current_thread)) {
 488                 _wapi_thread_dispatch_apc_queue (current_thread);
 489                 return WAIT_IO_COMPLETION;
 490         }
 491
 492         while(1) {
 493 #ifdef DEBUG
 494                 g_message (G_GNUC_PRETTY_FUNCTION ": locking signal mutex");
 495 #endif
 496
 497                 pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_signal_mutex, NULL);
 498                 thr_ret = _wapi_handle_lock_signal_mutex ();
 499                 g_assert (thr_ret == 0);
 500
 501                 if(timeout==INFINITE) {
 502                         ret=_wapi_handle_wait_signal ();
 503                 } else {
 504                         ret=_wapi_handle_timedwait_signal (&abstime);
 505                 }
 506
 507 #ifdef DEBUG
 508                 g_message (G_GNUC_PRETTY_FUNCTION ": unlocking signal mutex");
 509 #endif
 510
 511                 thr_ret = _wapi_handle_unlock_signal_mutex (NULL);
 512                 g_assert (thr_ret == 0);
 513                 pthread_cleanup_pop (0);
 514
 515                 if (alertable && _wapi_thread_apc_pending (current_thread)) {
 516                         _wapi_thread_dispatch_apc_queue (current_thread);
 517                         return WAIT_IO_COMPLETION;
 518                 }
 519
 520                 if(ret==0) {
 521                         /* Something was signalled ... */
 522                         done = test_and_own (numobjects, handles, waitall,
 523                                              &count, &lowest);
 524                         if(done==TRUE) {
 525                                 return(WAIT_OBJECT_0+lowest);
 526                         }
 527                 } else {
 528                         /* Timeout or other error */
 529 #ifdef DEBUG
 530                         g_message (G_GNUC_PRETTY_FUNCTION ": wait returned error: %s", strerror (ret));
 531 #endif
 532
 533                         if(ret==ETIMEDOUT) {
 534                                 return(WAIT_TIMEOUT);
 535                         } else {
 536                                 return(WAIT_FAILED);
 537                         }
 538                 }
 539         }
 540 }
 541
 542 guint32 WaitForMultipleObjects(guint32 numobjects, gpointer *handles,
 543                                gboolean waitall, guint32 timeout)
 544 {
 545         return WaitForMultipleObjectsEx(numobjects, handles, waitall, timeout, FALSE);
 546 }