3 * Runtime support for managed Event on Unix
6 * Ludovic Henry (luhenry@microsoft.com)
8 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
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"
24 mono_w32event_create_full (MonoBoolean manual, MonoBoolean initial, const gchar *name, gint32 *err);
27 mono_w32event_open (const gchar *utf8_name, gint32 rights G_GNUC_UNUSED, gint32 *error);
34 struct MonoW32HandleNamedEvent {
36 MonoW32HandleNamespace sharedns;
39 static gboolean event_handle_own (gpointer handle, MonoW32HandleType type, gboolean *abandoned)
41 MonoW32HandleEvent *event_handle;
46 ok = mono_w32handle_lookup (handle, type, (gpointer *)&event_handle);
48 g_warning ("%s: error looking up %s handle %p",
49 __func__, mono_w32handle_get_typename (type), handle);
53 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: owning %s handle %p",
54 __func__, mono_w32handle_get_typename (type), handle);
56 if (!event_handle->manual) {
57 g_assert (event_handle->set_count > 0);
58 event_handle->set_count --;
60 if (event_handle->set_count == 0)
61 mono_w32handle_set_signal_state (handle, FALSE, FALSE);
67 static void event_signal(gpointer handle)
69 ves_icall_System_Threading_Events_SetEvent_internal (handle);
72 static gboolean event_own (gpointer handle, gboolean *abandoned)
74 return event_handle_own (handle, MONO_W32HANDLE_EVENT, abandoned);
77 static void namedevent_signal (gpointer handle)
79 ves_icall_System_Threading_Events_SetEvent_internal (handle);
82 /* NB, always called with the shared handle lock held */
83 static gboolean namedevent_own (gpointer handle, gboolean *abandoned)
85 return event_handle_own (handle, MONO_W32HANDLE_NAMEDEVENT, abandoned);
88 static void event_details (gpointer data)
90 MonoW32HandleEvent *event = (MonoW32HandleEvent *)data;
91 g_print ("manual: %s, set_count: %d",
92 event->manual ? "TRUE" : "FALSE", event->set_count);
95 static void namedevent_details (gpointer data)
97 MonoW32HandleNamedEvent *namedevent = (MonoW32HandleNamedEvent *)data;
98 g_print ("manual: %s, set_count: %d, name: \"%s\"",
99 namedevent->e.manual ? "TRUE" : "FALSE", namedevent->e.set_count, namedevent->sharedns.name);
102 static const gchar* event_typename (void)
107 static gsize event_typesize (void)
109 return sizeof (MonoW32HandleEvent);
112 static const gchar* namedevent_typename (void)
117 static gsize namedevent_typesize (void)
119 return sizeof (MonoW32HandleNamedEvent);
123 mono_w32event_init (void)
125 static MonoW32HandleOps event_ops = {
127 event_signal, /* signal */
130 NULL, /* special_wait */
132 event_details, /* details */
133 event_typename, /* typename */
134 event_typesize, /* typesize */
137 static MonoW32HandleOps namedevent_ops = {
139 namedevent_signal, /* signal */
140 namedevent_own, /* own */
142 NULL, /* special_wait */
144 namedevent_details, /* details */
145 namedevent_typename, /* typename */
146 namedevent_typesize, /* typesize */
149 mono_w32handle_register_ops (MONO_W32HANDLE_EVENT, &event_ops);
150 mono_w32handle_register_ops (MONO_W32HANDLE_NAMEDEVENT, &namedevent_ops);
152 mono_w32handle_register_capabilities (MONO_W32HANDLE_EVENT,
153 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SIGNAL));
154 mono_w32handle_register_capabilities (MONO_W32HANDLE_NAMEDEVENT,
155 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SIGNAL));
159 mono_w32event_create (gboolean manual, gboolean initial)
164 handle = mono_w32event_create_full (manual, initial, NULL, &error);
165 if (error != ERROR_SUCCESS)
172 mono_w32event_close (gpointer handle)
174 return mono_w32handle_close (handle);
178 mono_w32event_set (gpointer handle)
180 ves_icall_System_Threading_Events_SetEvent_internal (handle);
184 mono_w32event_reset (gpointer handle)
186 ves_icall_System_Threading_Events_ResetEvent_internal (handle);
189 static gpointer event_handle_create (MonoW32HandleEvent *event_handle, MonoW32HandleType type, gboolean manual, gboolean initial)
193 event_handle->manual = manual;
194 event_handle->set_count = (initial && !manual) ? 1 : 0;
196 handle = mono_w32handle_new (type, event_handle);
197 if (handle == INVALID_HANDLE_VALUE) {
198 g_warning ("%s: error creating %s handle",
199 __func__, mono_w32handle_get_typename (type));
200 mono_w32error_set_last (ERROR_GEN_FAILURE);
204 mono_w32handle_lock_handle (handle);
207 mono_w32handle_set_signal_state (handle, TRUE, FALSE);
209 mono_w32handle_unlock_handle (handle);
211 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: created %s handle %p",
212 __func__, mono_w32handle_get_typename (type), handle);
217 static gpointer event_create (gboolean manual, gboolean initial)
219 MonoW32HandleEvent event_handle;
220 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: creating %s handle",
221 __func__, mono_w32handle_get_typename (MONO_W32HANDLE_EVENT));
222 return event_handle_create (&event_handle, MONO_W32HANDLE_EVENT, manual, initial);
225 static gpointer namedevent_create (gboolean manual, gboolean initial, const gchar *utf8_name G_GNUC_UNUSED)
229 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: creating %s handle",
230 __func__, mono_w32handle_get_typename (MONO_W32HANDLE_NAMEDEVENT));
232 /* w32 seems to guarantee that opening named objects can't race each other */
233 mono_w32handle_namespace_lock ();
235 glong utf8_len = strlen (utf8_name);
237 handle = mono_w32handle_namespace_search_handle (MONO_W32HANDLE_NAMEDEVENT, utf8_name);
238 if (handle == INVALID_HANDLE_VALUE) {
239 /* The name has already been used for a different object. */
241 mono_w32error_set_last (ERROR_INVALID_HANDLE);
243 /* Not an error, but this is how the caller is informed that the event wasn't freshly created */
244 mono_w32error_set_last (ERROR_ALREADY_EXISTS);
246 /* mono_w32handle_namespace_search_handle already adds a ref to the handle */
248 /* A new named event */
249 MonoW32HandleNamedEvent namedevent_handle;
251 size_t len = utf8_len < MAX_PATH ? utf8_len : MAX_PATH;
252 memcpy (&namedevent_handle.sharedns.name [0], utf8_name, len);
253 namedevent_handle.sharedns.name [len] = '\0';
255 handle = event_handle_create ((MonoW32HandleEvent*) &namedevent_handle, MONO_W32HANDLE_NAMEDEVENT, manual, initial);
258 mono_w32handle_namespace_unlock ();
264 mono_w32event_create_full (MonoBoolean manual, MonoBoolean initial, const gchar *name, gint32 *error)
268 /* Need to blow away any old errors here, because code tests
269 * for ERROR_ALREADY_EXISTS on success (!) to see if an event
270 * was freshly created */
271 mono_w32error_set_last (ERROR_SUCCESS);
273 event = name ? namedevent_create (manual, initial, name) : event_create (manual, initial);
275 *error = mono_w32error_get_last ();
281 ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoStringHandle name, gint32 *err, MonoError *error)
284 gchar *utf8_name = mono_string_handle_to_utf8 (name, error);
285 return_val_if_nok (error, NULL);
286 gpointer result = mono_w32event_create_full (manual, initial, utf8_name, err);
292 ves_icall_System_Threading_Events_SetEvent_internal (gpointer handle)
294 MonoW32HandleType type;
295 MonoW32HandleEvent *event_handle;
297 if (handle == NULL) {
298 mono_w32error_set_last (ERROR_INVALID_HANDLE);
302 switch (type = mono_w32handle_get_type (handle)) {
303 case MONO_W32HANDLE_EVENT:
304 case MONO_W32HANDLE_NAMEDEVENT:
307 mono_w32error_set_last (ERROR_INVALID_HANDLE);
311 if (!mono_w32handle_lookup (handle, type, (gpointer *)&event_handle)) {
312 g_warning ("%s: error looking up %s handle %p",
313 __func__, mono_w32handle_get_typename (type), handle);
317 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: setting %s handle %p",
318 __func__, mono_w32handle_get_typename (type), handle);
320 mono_w32handle_lock_handle (handle);
322 if (!event_handle->manual) {
323 event_handle->set_count = 1;
324 mono_w32handle_set_signal_state (handle, TRUE, FALSE);
326 mono_w32handle_set_signal_state (handle, TRUE, TRUE);
329 mono_w32handle_unlock_handle (handle);
335 ves_icall_System_Threading_Events_ResetEvent_internal (gpointer handle)
337 MonoW32HandleType type;
338 MonoW32HandleEvent *event_handle;
340 mono_w32error_set_last (ERROR_SUCCESS);
342 if (handle == NULL) {
343 mono_w32error_set_last (ERROR_INVALID_HANDLE);
347 switch (type = mono_w32handle_get_type (handle)) {
348 case MONO_W32HANDLE_EVENT:
349 case MONO_W32HANDLE_NAMEDEVENT:
352 mono_w32error_set_last (ERROR_INVALID_HANDLE);
356 if (!mono_w32handle_lookup (handle, type, (gpointer *)&event_handle)) {
357 g_warning ("%s: error looking up %s handle %p",
358 __func__, mono_w32handle_get_typename (type), handle);
362 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: resetting %s handle %p",
363 __func__, mono_w32handle_get_typename (type), handle);
365 mono_w32handle_lock_handle (handle);
367 if (!mono_w32handle_issignalled (handle)) {
368 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: no need to reset %s handle %p",
369 __func__, mono_w32handle_get_typename (type), handle);
371 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: obtained write lock on %s handle %p",
372 __func__, mono_w32handle_get_typename (type), handle);
374 mono_w32handle_set_signal_state (handle, FALSE, FALSE);
377 event_handle->set_count = 0;
379 mono_w32handle_unlock_handle (handle);
385 ves_icall_System_Threading_Events_CloseEvent_internal (gpointer handle)
387 mono_w32handle_close (handle);
391 ves_icall_System_Threading_Events_OpenEvent_internal (MonoStringHandle name, gint32 rights G_GNUC_UNUSED, gint32 *err, MonoError *error)
394 gchar *utf8_name = mono_string_handle_to_utf8 (name, error);
395 return_val_if_nok (error, NULL);
396 gpointer handle = mono_w32event_open (utf8_name, rights, err);
402 mono_w32event_open (const gchar *utf8_name, gint32 rights G_GNUC_UNUSED, gint32 *error)
405 *error = ERROR_SUCCESS;
407 /* w32 seems to guarantee that opening named objects can't race each other */
408 mono_w32handle_namespace_lock ();
410 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Opening named event [%s]", __func__, utf8_name);
412 handle = mono_w32handle_namespace_search_handle (MONO_W32HANDLE_NAMEDEVENT, utf8_name);
413 if (handle == INVALID_HANDLE_VALUE) {
414 /* The name has already been used for a different object. */
415 *error = ERROR_INVALID_HANDLE;
417 } else if (!handle) {
418 /* This name doesn't exist */
419 *error = ERROR_FILE_NOT_FOUND;
423 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning named event handle %p", __func__, handle);
426 mono_w32handle_namespace_unlock ();
431 MonoW32HandleNamespace*
432 mono_w32event_get_namespace (MonoW32HandleNamedEvent *event)
434 return &event->sharedns;