mono/metadata/w32event-unix.c

   1 /**
   2  * \file
   3  * Runtime support for managed Event on Unix
   4  *
   5  * Author:
   6  *      Ludovic Henry (luhenry@microsoft.com)
   7  *
   8  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   9  */
  10
  11 #include "w32event.h"
  12
  13 #include "w32error.h"
  14 #include "w32handle-namespace.h"
  15 #include "mono/utils/mono-error-internals.h"
  16 #include "mono/utils/mono-logger-internals.h"
  17 #include "mono/metadata/handle.h"
  18 #include "mono/metadata/object-internals.h"
  19 #include "mono/metadata/w32handle.h"
  20
  21 #define MAX_PATH 260
  22
  23 static gpointer
  24 mono_w32event_create_full (MonoBoolean manual, MonoBoolean initial, const gchar *name, gint32 *err);
  25
  26
  27 typedef struct {
  28         gboolean manual;
  29         guint32 set_count;
  30 } MonoW32HandleEvent;
  31
  32 struct MonoW32HandleNamedEvent {
  33         MonoW32HandleEvent e;
  34         MonoW32HandleNamespace sharedns;
  35 };
  36
  37 static gboolean event_handle_own (gpointer handle, MonoW32HandleType type, gboolean *abandoned)
  38 {
  39         MonoW32HandleEvent *event_handle;
  40         gboolean ok;
  41
  42         *abandoned = FALSE;
  43
  44         ok = mono_w32handle_lookup (handle, type, (gpointer *)&event_handle);
  45         if (!ok) {
  46                 g_warning ("%s: error looking up %s handle %p",
  47                         __func__, mono_w32handle_get_typename (type), handle);
  48                 return FALSE;
  49         }
  50
  51         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: owning %s handle %p",
  52                 __func__, mono_w32handle_get_typename (type), handle);
  53
  54         if (!event_handle->manual) {
  55                 g_assert (event_handle->set_count > 0);
  56                 event_handle->set_count --;
  57
  58                 if (event_handle->set_count == 0)
  59                         mono_w32handle_set_signal_state (handle, FALSE, FALSE);
  60         }
  61
  62         return TRUE;
  63 }
  64
  65 static void event_signal(gpointer handle)
  66 {
  67         ves_icall_System_Threading_Events_SetEvent_internal (handle);
  68 }
  69
  70 static gboolean event_own (gpointer handle, gboolean *abandoned)
  71 {
  72         return event_handle_own (handle, MONO_W32HANDLE_EVENT, abandoned);
  73 }
  74
  75 static void namedevent_signal (gpointer handle)
  76 {
  77         ves_icall_System_Threading_Events_SetEvent_internal (handle);
  78 }
  79
  80 /* NB, always called with the shared handle lock held */
  81 static gboolean namedevent_own (gpointer handle, gboolean *abandoned)
  82 {
  83         return event_handle_own (handle, MONO_W32HANDLE_NAMEDEVENT, abandoned);
  84 }
  85
  86 static void event_details (gpointer data)
  87 {
  88         MonoW32HandleEvent *event = (MonoW32HandleEvent *)data;
  89         g_print ("manual: %s, set_count: %d",
  90                 event->manual ? "TRUE" : "FALSE", event->set_count);
  91 }
  92
  93 static void namedevent_details (gpointer data)
  94 {
  95         MonoW32HandleNamedEvent *namedevent = (MonoW32HandleNamedEvent *)data;
  96         g_print ("manual: %s, set_count: %d, name: \"%s\"",
  97                 namedevent->e.manual ? "TRUE" : "FALSE", namedevent->e.set_count, namedevent->sharedns.name);
  98 }
  99
 100 static const gchar* event_typename (void)
 101 {
 102         return "Event";
 103 }
 104
 105 static gsize event_typesize (void)
 106 {
 107         return sizeof (MonoW32HandleEvent);
 108 }
 109
 110 static const gchar* namedevent_typename (void)
 111 {
 112         return "N.Event";
 113 }
 114
 115 static gsize namedevent_typesize (void)
 116 {
 117         return sizeof (MonoW32HandleNamedEvent);
 118 }
 119
 120 void
 121 mono_w32event_init (void)
 122 {
 123         static MonoW32HandleOps event_ops = {
 124                 NULL,                   /* close */
 125                 event_signal,           /* signal */
 126                 event_own,              /* own */
 127                 NULL,                   /* is_owned */
 128                 NULL,                   /* special_wait */
 129                 NULL,                   /* prewait */
 130                 event_details,  /* details */
 131                 event_typename, /* typename */
 132                 event_typesize, /* typesize */
 133         };
 134
 135         static MonoW32HandleOps namedevent_ops = {
 136                 NULL,                   /* close */
 137                 namedevent_signal,      /* signal */
 138                 namedevent_own,         /* own */
 139                 NULL,                   /* is_owned */
 140                 NULL,                   /* special_wait */
 141                 NULL,                   /* prewait */
 142                 namedevent_details,     /* details */
 143                 namedevent_typename, /* typename */
 144                 namedevent_typesize, /* typesize */
 145         };
 146
 147         mono_w32handle_register_ops (MONO_W32HANDLE_EVENT,      &event_ops);
 148         mono_w32handle_register_ops (MONO_W32HANDLE_NAMEDEVENT, &namedevent_ops);
 149
 150         mono_w32handle_register_capabilities (MONO_W32HANDLE_EVENT,
 151                 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SIGNAL));
 152         mono_w32handle_register_capabilities (MONO_W32HANDLE_NAMEDEVENT,
 153                 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SIGNAL));
 154 }
 155
 156 gpointer
 157 mono_w32event_create (gboolean manual, gboolean initial)
 158 {
 159         gpointer handle;
 160         gint32 error;
 161
 162         handle = mono_w32event_create_full (manual, initial, NULL, &error);
 163         if (error != ERROR_SUCCESS)
 164                 g_assert (!handle);
 165
 166         return handle;
 167 }
 168
 169 gboolean
 170 mono_w32event_close (gpointer handle)
 171 {
 172         return mono_w32handle_close (handle);
 173 }
 174
 175 void
 176 mono_w32event_set (gpointer handle)
 177 {
 178         ves_icall_System_Threading_Events_SetEvent_internal (handle);
 179 }
 180
 181 void
 182 mono_w32event_reset (gpointer handle)
 183 {
 184         ves_icall_System_Threading_Events_ResetEvent_internal (handle);
 185 }
 186
 187 static gpointer event_handle_create (MonoW32HandleEvent *event_handle, MonoW32HandleType type, gboolean manual, gboolean initial)
 188 {
 189         gpointer handle;
 190
 191         event_handle->manual = manual;
 192         event_handle->set_count = (initial && !manual) ? 1 : 0;
 193
 194         handle = mono_w32handle_new (type, event_handle);
 195         if (handle == INVALID_HANDLE_VALUE) {
 196                 g_warning ("%s: error creating %s handle",
 197                         __func__, mono_w32handle_get_typename (type));
 198                 mono_w32error_set_last (ERROR_GEN_FAILURE);
 199                 return NULL;
 200         }
 201
 202         mono_w32handle_lock_handle (handle);
 203
 204         if (initial)
 205                 mono_w32handle_set_signal_state (handle, TRUE, FALSE);
 206
 207         mono_w32handle_unlock_handle (handle);
 208
 209         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: created %s handle %p",
 210                 __func__, mono_w32handle_get_typename (type), handle);
 211
 212         return handle;
 213 }
 214
 215 static gpointer event_create (gboolean manual, gboolean initial)
 216 {
 217         MonoW32HandleEvent event_handle;
 218         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: creating %s handle",
 219                 __func__, mono_w32handle_get_typename (MONO_W32HANDLE_EVENT));
 220         return event_handle_create (&event_handle, MONO_W32HANDLE_EVENT, manual, initial);
 221 }
 222
 223 static gpointer namedevent_create (gboolean manual, gboolean initial, const gchar *utf8_name G_GNUC_UNUSED)
 224 {
 225         gpointer handle;
 226
 227         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: creating %s handle",
 228                 __func__, mono_w32handle_get_typename (MONO_W32HANDLE_NAMEDEVENT));
 229
 230         /* w32 seems to guarantee that opening named objects can't race each other */
 231         mono_w32handle_namespace_lock ();
 232
 233         glong utf8_len = strlen (utf8_name);
 234
 235         handle = mono_w32handle_namespace_search_handle (MONO_W32HANDLE_NAMEDEVENT, utf8_name);
 236         if (handle == INVALID_HANDLE_VALUE) {
 237                 /* The name has already been used for a different object. */
 238                 handle = NULL;
 239                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
 240         } else if (handle) {
 241                 /* Not an error, but this is how the caller is informed that the event wasn't freshly created */
 242                 mono_w32error_set_last (ERROR_ALREADY_EXISTS);
 243
 244                 /* mono_w32handle_namespace_search_handle already adds a ref to the handle */
 245         } else {
 246                 /* A new named event */
 247                 MonoW32HandleNamedEvent namedevent_handle;
 248
 249                 size_t len = utf8_len < MAX_PATH ? utf8_len : MAX_PATH;
 250                 memcpy (&namedevent_handle.sharedns.name [0], utf8_name, len);
 251                 namedevent_handle.sharedns.name [len] = '\0';
 252
 253                 handle = event_handle_create ((MonoW32HandleEvent*) &namedevent_handle, MONO_W32HANDLE_NAMEDEVENT, manual, initial);
 254         }
 255
 256         mono_w32handle_namespace_unlock ();
 257
 258         return handle;
 259 }
 260
 261 gpointer
 262 mono_w32event_create_full (MonoBoolean manual, MonoBoolean initial, const gchar *name, gint32 *error)
 263 {
 264         gpointer event;
 265
 266         /* Need to blow away any old errors here, because code tests
 267          * for ERROR_ALREADY_EXISTS on success (!) to see if an event
 268          * was freshly created */
 269         mono_w32error_set_last (ERROR_SUCCESS);
 270
 271         event = name ? namedevent_create (manual, initial, name) : event_create (manual, initial);
 272
 273         *error = mono_w32error_get_last ();
 274
 275         return event;
 276 }
 277
 278 gpointer
 279 ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoStringHandle name, gint32 *err, MonoError *error)
 280 {
 281         error_init (error);
 282         gchar *utf8_name = mono_string_handle_to_utf8 (name, error);
 283         return_val_if_nok (error, NULL);
 284         gpointer result = mono_w32event_create_full (manual, initial, utf8_name, err);
 285         g_free (utf8_name);
 286         return result;
 287 }
 288
 289 gboolean
 290 ves_icall_System_Threading_Events_SetEvent_internal (gpointer handle)
 291 {
 292         MonoW32HandleType type;
 293         MonoW32HandleEvent *event_handle;
 294
 295         if (handle == NULL) {
 296                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
 297                 return(FALSE);
 298         }
 299
 300         switch (type = mono_w32handle_get_type (handle)) {
 301         case MONO_W32HANDLE_EVENT:
 302         case MONO_W32HANDLE_NAMEDEVENT:
 303                 break;
 304         default:
 305                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
 306                 return FALSE;
 307         }
 308
 309         if (!mono_w32handle_lookup (handle, type, (gpointer *)&event_handle)) {
 310                 g_warning ("%s: error looking up %s handle %p",
 311                         __func__, mono_w32handle_get_typename (type), handle);
 312                 return FALSE;
 313         }
 314
 315         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: setting %s handle %p",
 316                 __func__, mono_w32handle_get_typename (type), handle);
 317
 318         mono_w32handle_lock_handle (handle);
 319
 320         if (!event_handle->manual) {
 321                 event_handle->set_count = 1;
 322                 mono_w32handle_set_signal_state (handle, TRUE, FALSE);
 323         } else {
 324                 mono_w32handle_set_signal_state (handle, TRUE, TRUE);
 325         }
 326
 327         mono_w32handle_unlock_handle (handle);
 328
 329         return TRUE;
 330 }
 331
 332 gboolean
 333 ves_icall_System_Threading_Events_ResetEvent_internal (gpointer handle)
 334 {
 335         MonoW32HandleType type;
 336         MonoW32HandleEvent *event_handle;
 337
 338         mono_w32error_set_last (ERROR_SUCCESS);
 339
 340         if (handle == NULL) {
 341                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
 342                 return(FALSE);
 343         }
 344
 345         switch (type = mono_w32handle_get_type (handle)) {
 346         case MONO_W32HANDLE_EVENT:
 347         case MONO_W32HANDLE_NAMEDEVENT:
 348                 break;
 349         default:
 350                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
 351                 return FALSE;
 352         }
 353
 354         if (!mono_w32handle_lookup (handle, type, (gpointer *)&event_handle)) {
 355                 g_warning ("%s: error looking up %s handle %p",
 356                         __func__, mono_w32handle_get_typename (type), handle);
 357                 return FALSE;
 358         }
 359
 360         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: resetting %s handle %p",
 361                 __func__, mono_w32handle_get_typename (type), handle);
 362
 363         mono_w32handle_lock_handle (handle);
 364
 365         if (!mono_w32handle_issignalled (handle)) {
 366                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: no need to reset %s handle %p",
 367                         __func__, mono_w32handle_get_typename (type), handle);
 368         } else {
 369                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: obtained write lock on %s handle %p",
 370                         __func__, mono_w32handle_get_typename (type), handle);
 371
 372                 mono_w32handle_set_signal_state (handle, FALSE, FALSE);
 373         }
 374
 375         event_handle->set_count = 0;
 376
 377         mono_w32handle_unlock_handle (handle);
 378
 379         return TRUE;
 380 }
 381
 382 void
 383 ves_icall_System_Threading_Events_CloseEvent_internal (gpointer handle)
 384 {
 385         mono_w32handle_close (handle);
 386 }
 387
 388 gpointer
 389 ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name, gint32 rights G_GNUC_UNUSED, gint32 *error)
 390 {
 391         gpointer handle;
 392         gchar *utf8_name;
 393
 394         *error = ERROR_SUCCESS;
 395
 396         /* w32 seems to guarantee that opening named objects can't race each other */
 397         mono_w32handle_namespace_lock ();
 398
 399         utf8_name = g_utf16_to_utf8 (mono_string_chars (name), -1, NULL, NULL, NULL);
 400
 401         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Opening named event [%s]", __func__, utf8_name);
 402
 403         handle = mono_w32handle_namespace_search_handle (MONO_W32HANDLE_NAMEDEVENT, utf8_name);
 404         if (handle == INVALID_HANDLE_VALUE) {
 405                 /* The name has already been used for a different object. */
 406                 *error = ERROR_INVALID_HANDLE;
 407                 goto cleanup;
 408         } else if (!handle) {
 409                 /* This name doesn't exist */
 410                 *error = ERROR_FILE_NOT_FOUND;
 411                 goto cleanup;
 412         }
 413
 414         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning named event handle %p", __func__, handle);
 415
 416 cleanup:
 417         g_free (utf8_name);
 418
 419         mono_w32handle_namespace_unlock ();
 420
 421         return handle;
 422 }
 423
 424 MonoW32HandleNamespace*
 425 mono_w32event_get_namespace (MonoW32HandleNamedEvent *event)
 426 {
 427         return &event->sharedns;
 428 }