2 * w32event-unix.c: Runtime support for managed Event on Unix
5 * Ludovic Henry (luhenry@microsoft.com)
7 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
13 #include "w32handle-namespace.h"
14 #include "mono/utils/mono-logger-internals.h"
15 #include "mono/metadata/w32handle.h"
24 struct MonoW32HandleNamedEvent {
26 MonoW32HandleNamespace sharedns;
29 static gboolean event_handle_own (gpointer handle, MonoW32HandleType type, gboolean *abandoned)
31 MonoW32HandleEvent *event_handle;
36 ok = mono_w32handle_lookup (handle, type, (gpointer *)&event_handle);
38 g_warning ("%s: error looking up %s handle %p",
39 __func__, mono_w32handle_get_typename (type), handle);
43 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: owning %s handle %p",
44 __func__, mono_w32handle_get_typename (type), handle);
46 if (!event_handle->manual) {
47 g_assert (event_handle->set_count > 0);
48 event_handle->set_count --;
50 if (event_handle->set_count == 0)
51 mono_w32handle_set_signal_state (handle, FALSE, FALSE);
57 static void event_signal(gpointer handle)
59 ves_icall_System_Threading_Events_SetEvent_internal (handle);
62 static gboolean event_own (gpointer handle, gboolean *abandoned)
64 return event_handle_own (handle, MONO_W32HANDLE_EVENT, abandoned);
67 static void namedevent_signal (gpointer handle)
69 ves_icall_System_Threading_Events_SetEvent_internal (handle);
72 /* NB, always called with the shared handle lock held */
73 static gboolean namedevent_own (gpointer handle, gboolean *abandoned)
75 return event_handle_own (handle, MONO_W32HANDLE_NAMEDEVENT, abandoned);
78 static void event_details (gpointer data)
80 MonoW32HandleEvent *event = (MonoW32HandleEvent *)data;
81 g_print ("manual: %s, set_count: %d",
82 event->manual ? "TRUE" : "FALSE", event->set_count);
85 static void namedevent_details (gpointer data)
87 MonoW32HandleNamedEvent *namedevent = (MonoW32HandleNamedEvent *)data;
88 g_print ("manual: %s, set_count: %d, name: \"%s\"",
89 namedevent->e.manual ? "TRUE" : "FALSE", namedevent->e.set_count, namedevent->sharedns.name);
92 static const gchar* event_typename (void)
97 static gsize event_typesize (void)
99 return sizeof (MonoW32HandleEvent);
102 static const gchar* namedevent_typename (void)
107 static gsize namedevent_typesize (void)
109 return sizeof (MonoW32HandleNamedEvent);
113 mono_w32event_init (void)
115 static MonoW32HandleOps event_ops = {
117 event_signal, /* signal */
120 NULL, /* special_wait */
122 event_details, /* details */
123 event_typename, /* typename */
124 event_typesize, /* typesize */
127 static MonoW32HandleOps namedevent_ops = {
129 namedevent_signal, /* signal */
130 namedevent_own, /* own */
132 NULL, /* special_wait */
134 namedevent_details, /* details */
135 namedevent_typename, /* typename */
136 namedevent_typesize, /* typesize */
139 mono_w32handle_register_ops (MONO_W32HANDLE_EVENT, &event_ops);
140 mono_w32handle_register_ops (MONO_W32HANDLE_NAMEDEVENT, &namedevent_ops);
142 mono_w32handle_register_capabilities (MONO_W32HANDLE_EVENT,
143 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SIGNAL));
144 mono_w32handle_register_capabilities (MONO_W32HANDLE_NAMEDEVENT,
145 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SIGNAL));
149 mono_w32event_create (gboolean manual, gboolean initial)
154 handle = ves_icall_System_Threading_Events_CreateEvent_internal (manual, initial, NULL, &error);
155 if (error != ERROR_SUCCESS)
162 mono_w32event_close (gpointer handle)
164 return mono_w32handle_close (handle);
168 mono_w32event_set (gpointer handle)
170 ves_icall_System_Threading_Events_SetEvent_internal (handle);
174 mono_w32event_reset (gpointer handle)
176 ves_icall_System_Threading_Events_ResetEvent_internal (handle);
179 static gpointer event_handle_create (MonoW32HandleEvent *event_handle, MonoW32HandleType type, gboolean manual, gboolean initial)
183 event_handle->manual = manual;
184 event_handle->set_count = (initial && !manual) ? 1 : 0;
186 handle = mono_w32handle_new (type, event_handle);
187 if (handle == INVALID_HANDLE_VALUE) {
188 g_warning ("%s: error creating %s handle",
189 __func__, mono_w32handle_get_typename (type));
190 mono_w32error_set_last (ERROR_GEN_FAILURE);
194 mono_w32handle_lock_handle (handle);
197 mono_w32handle_set_signal_state (handle, TRUE, FALSE);
199 mono_w32handle_unlock_handle (handle);
201 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: created %s handle %p",
202 __func__, mono_w32handle_get_typename (type), handle);
207 static gpointer event_create (gboolean manual, gboolean initial)
209 MonoW32HandleEvent event_handle;
210 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: creating %s handle",
211 __func__, mono_w32handle_get_typename (MONO_W32HANDLE_EVENT));
212 return event_handle_create (&event_handle, MONO_W32HANDLE_EVENT, manual, initial);
215 static gpointer namedevent_create (gboolean manual, gboolean initial, const gunichar2 *name G_GNUC_UNUSED)
220 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: creating %s handle",
221 __func__, mono_w32handle_get_typename (MONO_W32HANDLE_NAMEDEVENT));
223 /* w32 seems to guarantee that opening named objects can't race each other */
224 mono_w32handle_namespace_lock ();
226 utf8_name = g_utf16_to_utf8 (name, -1, NULL, NULL, NULL);
228 handle = mono_w32handle_namespace_search_handle (MONO_W32HANDLE_NAMEDEVENT, utf8_name);
229 if (handle == INVALID_HANDLE_VALUE) {
230 /* The name has already been used for a different object. */
232 mono_w32error_set_last (ERROR_INVALID_HANDLE);
234 /* Not an error, but this is how the caller is informed that the event wasn't freshly created */
235 mono_w32error_set_last (ERROR_ALREADY_EXISTS);
237 /* mono_w32handle_namespace_search_handle already adds a ref to the handle */
239 /* A new named event */
240 MonoW32HandleNamedEvent namedevent_handle;
242 strncpy (&namedevent_handle.sharedns.name [0], utf8_name, MAX_PATH);
243 namedevent_handle.sharedns.name [MAX_PATH] = '\0';
245 handle = event_handle_create ((MonoW32HandleEvent*) &namedevent_handle, MONO_W32HANDLE_NAMEDEVENT, manual, initial);
250 mono_w32handle_namespace_unlock ();
256 ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoString *name, gint32 *error)
260 /* Need to blow away any old errors here, because code tests
261 * for ERROR_ALREADY_EXISTS on success (!) to see if an event
262 * was freshly created */
263 mono_w32error_set_last (ERROR_SUCCESS);
265 event = name ? namedevent_create (manual, initial, mono_string_chars (name)) : event_create (manual, initial);
267 *error = mono_w32error_get_last ();
273 ves_icall_System_Threading_Events_SetEvent_internal (gpointer handle)
275 MonoW32HandleType type;
276 MonoW32HandleEvent *event_handle;
278 if (handle == NULL) {
279 mono_w32error_set_last (ERROR_INVALID_HANDLE);
283 switch (type = mono_w32handle_get_type (handle)) {
284 case MONO_W32HANDLE_EVENT:
285 case MONO_W32HANDLE_NAMEDEVENT:
288 mono_w32error_set_last (ERROR_INVALID_HANDLE);
292 if (!mono_w32handle_lookup (handle, type, (gpointer *)&event_handle)) {
293 g_warning ("%s: error looking up %s handle %p",
294 __func__, mono_w32handle_get_typename (type), handle);
298 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: setting %s handle %p",
299 __func__, mono_w32handle_get_typename (type), handle);
301 mono_w32handle_lock_handle (handle);
303 if (!event_handle->manual) {
304 event_handle->set_count = 1;
305 mono_w32handle_set_signal_state (handle, TRUE, FALSE);
307 mono_w32handle_set_signal_state (handle, TRUE, TRUE);
310 mono_w32handle_unlock_handle (handle);
316 ves_icall_System_Threading_Events_ResetEvent_internal (gpointer handle)
318 MonoW32HandleType type;
319 MonoW32HandleEvent *event_handle;
321 mono_w32error_set_last (ERROR_SUCCESS);
323 if (handle == NULL) {
324 mono_w32error_set_last (ERROR_INVALID_HANDLE);
328 switch (type = mono_w32handle_get_type (handle)) {
329 case MONO_W32HANDLE_EVENT:
330 case MONO_W32HANDLE_NAMEDEVENT:
333 mono_w32error_set_last (ERROR_INVALID_HANDLE);
337 if (!mono_w32handle_lookup (handle, type, (gpointer *)&event_handle)) {
338 g_warning ("%s: error looking up %s handle %p",
339 __func__, mono_w32handle_get_typename (type), handle);
343 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: resetting %s handle %p",
344 __func__, mono_w32handle_get_typename (type), handle);
346 mono_w32handle_lock_handle (handle);
348 if (!mono_w32handle_issignalled (handle)) {
349 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: no need to reset %s handle %p",
350 __func__, mono_w32handle_get_typename (type), handle);
352 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: obtained write lock on %s handle %p",
353 __func__, mono_w32handle_get_typename (type), handle);
355 mono_w32handle_set_signal_state (handle, FALSE, FALSE);
358 event_handle->set_count = 0;
360 mono_w32handle_unlock_handle (handle);
366 ves_icall_System_Threading_Events_CloseEvent_internal (gpointer handle)
368 mono_w32handle_close (handle);
372 ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name, gint32 rights G_GNUC_UNUSED, gint32 *error)
377 *error = ERROR_SUCCESS;
379 /* w32 seems to guarantee that opening named objects can't race each other */
380 mono_w32handle_namespace_lock ();
382 utf8_name = g_utf16_to_utf8 (mono_string_chars (name), -1, NULL, NULL, NULL);
384 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Opening named event [%s]", __func__, utf8_name);
386 handle = mono_w32handle_namespace_search_handle (MONO_W32HANDLE_NAMEDEVENT, utf8_name);
387 if (handle == INVALID_HANDLE_VALUE) {
388 /* The name has already been used for a different object. */
389 *error = ERROR_INVALID_HANDLE;
391 } else if (!handle) {
392 /* This name doesn't exist */
393 *error = ERROR_FILE_NOT_FOUND;
397 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning named event handle %p", __func__, handle);
402 mono_w32handle_namespace_unlock ();
407 MonoW32HandleNamespace*
408 mono_w32event_get_namespace (MonoW32HandleNamedEvent *event)
410 return &event->sharedns;