?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
In Test/System.Data:
[mono-project.git] / mono / metadata / threads.c
blobdfbe2f24ddedc3857b43fbd83b7d4aba8faf9209
1 /*
2 * threads.c: Thread support internal calls
3 *
4 * Author:
5 * Dick Porter (dick@ximian.com)
6 * Paolo Molaro (lupus@ximian.com)
7 * Patrik Torstensson (patrik.torstensson@labs2.com)
8 *
9 * (C) 2001 Ximian, Inc.
10 */
11
12 #include <config.h>
13 #ifdef PLATFORM_WIN32
14 #define _WIN32_WINNT 0x0500
15 #endif
16
17 #include <glib.h>
18 #include <signal.h>
19 #include <string.h>
20
21 #include <mono/metadata/object.h>
22 #include <mono/metadata/domain-internals.h>
23 #include <mono/metadata/profiler-private.h>
24 #include <mono/metadata/threads.h>
25 #include <mono/metadata/threadpool.h>
26 #include <mono/metadata/threads-types.h>
27 #include <mono/metadata/exception.h>
28 #include <mono/metadata/environment.h>
29 #include <mono/metadata/monitor.h>
30 #include <mono/metadata/gc-internal.h>
31 #include <mono/metadata/marshal.h>
32 #include <mono/io-layer/io-layer.h>
33 #include <mono/metadata/object-internals.h>
34 #include <mono/metadata/mono-debug-debugger.h>
35 #include <mono/utils/mono-compiler.h>
36
37 #include <mono/os/gc_wrapper.h>
38
39 /*#define THREAD_DEBUG(a) do { a; } while (0)*/
40 #define THREAD_DEBUG(a)
41 /*#define THREAD_WAIT_DEBUG(a) do { a; } while (0)*/
42 #define THREAD_WAIT_DEBUG(a)
43 /*#define LIBGC_DEBUG(a) do { a; } while (0)*/
44 #define LIBGC_DEBUG(a)
45
46 /* Provide this for systems with glib < 2.6 */
47 #ifndef G_GSIZE_FORMAT
48 # if GLIB_SIZEOF_LONG == 8
49 # define G_GSIZE_FORMAT "lu"
50 # else
51 # define G_GSIZE_FORMAT "u"
52 # endif
53 #endif
54
55 struct StartInfo
56 {
57 guint32 (*func)(void *);
58 MonoThread *obj;
59 MonoObject *delegate;
60 void *start_arg;
61 MonoDomain *domain;
62 };
63
64 typedef union {
65 gint32 ival;
66 gfloat fval;
67 } IntFloatUnion;
68
69 typedef union {
70 gint64 ival;
71 gdouble fval;
72 } LongDoubleUnion;
73
74 typedef struct {
75 int idx;
76 int offset;
77 } StaticDataInfo;
78
79 /* Number of cached culture objects in the MonoThread->cached_culture_info array
80 * (per-type): we use the first NUM entries for CultureInfo and the last for
81 * UICultureInfo. So the size of the array is really NUM_CACHED_CULTURES * 2.
82 */
83 #define NUM_CACHED_CULTURES 4
84 #define CULTURES_START_IDX 0
85 #define UICULTURES_START_IDX NUM_CACHED_CULTURES
86
87 /*
88 * The "os_handle" field of the WaitHandle class.
89 */
90 static MonoClassField *wait_handle_os_handle_field = NULL;
91
92 /* Controls access to the 'threads' hash table */
93 #define mono_threads_lock() EnterCriticalSection (&threads_mutex)
94 #define mono_threads_unlock() LeaveCriticalSection (&threads_mutex)
95 static CRITICAL_SECTION threads_mutex;
96
97 /* Controls access to context static data */
98 #define mono_contexts_lock() EnterCriticalSection (&contexts_mutex)
99 #define mono_contexts_unlock() LeaveCriticalSection (&contexts_mutex)
100 static CRITICAL_SECTION contexts_mutex;
101
102 /* Holds current status of static data heap */
103 static StaticDataInfo thread_static_info;
104 static StaticDataInfo context_static_info;
105
106 /* The hash of existing threads (key is thread ID) that need joining
107 * before exit
108 */
109 static MonoGHashTable *threads=NULL;
110
111 /* The TLS key that holds the MonoObject assigned to each thread */
112 static guint32 current_object_key = -1;
113
114 #ifdef HAVE_KW_THREAD
115 /* we need to use both the Tls* functions and __thread because
116 * the gc needs to see all the threads
117 */
118 static __thread MonoThread * tls_current_object MONO_TLS_FAST;
119 #define SET_CURRENT_OBJECT(x) do { \
120 tls_current_object = x; \
121 TlsSetValue (current_object_key, x); \
122 } while (FALSE)
123 #define GET_CURRENT_OBJECT() tls_current_object
124 #else
125 #define SET_CURRENT_OBJECT(x) TlsSetValue (current_object_key, x);
126 #define GET_CURRENT_OBJECT() (MonoThread*) TlsGetValue (current_object_key);
127 #endif
128
129 /* function called at thread start */
130 static MonoThreadStartCB mono_thread_start_cb = NULL;
131
132 /* function called at thread attach */
133 static MonoThreadAttachCB mono_thread_attach_cb = NULL;
134
135 /* function called at thread cleanup */
136 static MonoThreadCleanupFunc mono_thread_cleanup_fn = NULL;
137
138 /* The default stack size for each thread */
139 static guint32 default_stacksize = 0;
140 #define default_stacksize_for_thread(thread) ((thread)->stack_size? (thread)->stack_size: default_stacksize)
141
142 static void thread_adjust_static_data (MonoThread *thread);
143 static void mono_init_static_data_info (StaticDataInfo *static_data);
144 static guint32 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align);
145 static gboolean mono_thread_resume (MonoThread* thread);
146 static void mono_thread_start (MonoThread *thread);
147 static void signal_thread_state_change (MonoThread *thread);
148
149 /* Spin lock for InterlockedXXX 64 bit functions */
150 #define mono_interlocked_lock() EnterCriticalSection (&interlocked_mutex)
151 #define mono_interlocked_unlock() LeaveCriticalSection (&interlocked_mutex)
152 static CRITICAL_SECTION interlocked_mutex;
153
154 /* global count of thread interruptions requested */
155 static gint32 thread_interruption_requested = 0;
156
157 /* Event signaled when a thread changes its background mode */
158 static HANDLE background_change_event;
159
160 guint32
161 mono_thread_get_tls_key (void)
162 {
163 return current_object_key;
164 }
165
166 gint32
167 mono_thread_get_tls_offset (void)
168 {
169 int offset;
170 MONO_THREAD_VAR_OFFSET (tls_current_object,offset);
171 return offset;
172 }
173
174 /* handle_store() and handle_remove() manage the array of threads that
175 * still need to be waited for when the main thread exits.
176 */
177 static void handle_store(MonoThread *thread)
178 {
179 mono_threads_lock ();
180
181 THREAD_DEBUG (g_message ("%s: thread %p ID %"G_GSIZE_FORMAT, __func__, thread, (gsize)thread->tid));
182
183 if(threads==NULL) {
184 MONO_GC_REGISTER_ROOT (threads);
185 threads=mono_g_hash_table_new(NULL, NULL);
186 }
187
188 /* We don't need to duplicate thread->handle, because it is
189 * only closed when the thread object is finalized by the GC.
190 */
191 mono_g_hash_table_insert(threads, (gpointer)(gsize)(thread->tid),
192 thread);
193
194 mono_threads_unlock ();
195 }
196
197 static void handle_remove(gsize tid)
198 {
199 THREAD_DEBUG (g_message ("%s: thread ID %"G_GSIZE_FORMAT, __func__, tid));
200
201 mono_threads_lock ();
202
203
204 if (threads)
205 mono_g_hash_table_remove (threads, (gpointer)tid);
206
207 mono_threads_unlock ();
208
209 /* Don't close the handle here, wait for the object finalizer
210 * to do it. Otherwise, the following race condition applies:
211 *
212 * 1) Thread exits (and handle_remove() closes the handle)
213 *
214 * 2) Some other handle is reassigned the same slot
215 *
216 * 3) Another thread tries to join the first thread, and
217 * blocks waiting for the reassigned handle to be signalled
218 * (which might never happen). This is possible, because the
219 * thread calling Join() still has a reference to the first
220 * thread's object.
221 */
222 }
223
224 static void thread_cleanup (MonoThread *thread)
225 {
226 g_assert (thread != NULL);
227
228 mono_release_type_locks (thread);
229
230 if (!mono_monitor_enter (thread->synch_lock))
231 return;
232
233 thread->state |= ThreadState_Stopped;
234 mono_monitor_exit (thread->synch_lock);
235
236 mono_profiler_thread_end (thread->tid);
237 handle_remove (thread->tid);
238
239 mono_thread_pop_appdomain_ref ();
240
241 if (thread->serialized_culture_info)
242 g_free (thread->serialized_culture_info);
243
244 thread->cached_culture_info = NULL;
245
246 if (mono_thread_cleanup_fn)
247 mono_thread_cleanup_fn (thread);
248 }
249
250 static guint32 WINAPI start_wrapper(void *data)
251 {
252 struct StartInfo *start_info=(struct StartInfo *)data;
253 guint32 (*start_func)(void *);
254 void *start_arg;
255 gsize tid;
256 MonoThread *thread=start_info->obj;
257 MonoObject *start_delegate = start_info->delegate;
258
259 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Start wrapper", __func__, GetCurrentThreadId ()));
260
261 /* We can be sure start_info->obj->tid and
262 * start_info->obj->handle have been set, because the thread
263 * was created suspended, and these values were set before the
264 * thread resumed
265 */
266
267 tid=thread->tid;
268
269 SET_CURRENT_OBJECT (thread);
270
271 if (!mono_domain_set (start_info->domain, FALSE)) {
272 /* No point in raising an appdomain_unloaded exception here */
273 /* FIXME: Cleanup here */
274 return 0;
275 }
276
277 start_func = start_info->func;
278 start_arg = start_info->start_arg;
279
280 /* This MUST be called before any managed code can be
281 * executed, as it calls the callback function that (for the
282 * jit) sets the lmf marker.
283 */
284 mono_thread_new_init (tid, &tid, start_func);
285 thread->stack_ptr = &tid;
286
287 LIBGC_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT",%d) Setting thread stack to %p", __func__, GetCurrentThreadId (), getpid (), thread->stack_ptr));
288
289 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Setting current_object_key to %p", __func__, GetCurrentThreadId (), thread));
290
291 mono_profiler_thread_start (tid);
292
293 if(thread->start_notify!=NULL) {
294 /* Let the thread that called Start() know we're
295 * ready
296 */
297 ReleaseSemaphore (thread->start_notify, 1, NULL);
298 }
299
300 g_free (start_info);
301
302 /* Every thread references the appdomain which created it */
303 mono_thread_push_appdomain_ref (mono_domain_get ());
304
305 thread_adjust_static_data (thread);
306 #ifdef DEBUG
307 g_message ("%s: start_wrapper for %"G_GSIZE_FORMAT, __func__,
308 thread->tid);
309 #endif
310
311 /* start_func is set only for unmanaged start functions */
312 if (start_func) {
313 start_func (start_arg);
314 } else {
315 void *args [1];
316 g_assert (start_delegate != NULL);
317 args [0] = start_arg;
318 /* we may want to handle the exception here. See comment below on unhandled exceptions */
319 mono_runtime_delegate_invoke (start_delegate, args, NULL);
320 }
321
322 /* If the thread calls ExitThread at all, this remaining code
323 * will not be executed, but the main thread will eventually
324 * call thread_cleanup() on this thread's behalf.
325 */
326
327 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Start wrapper terminating", __func__, GetCurrentThreadId ()));
328
329 thread_cleanup (thread);
330
331 /* Remove the reference to the thread object in the TLS data,
332 * so the thread object can be finalized. This won't be
333 * reached if the thread threw an uncaught exception, so those
334 * thread handles will stay referenced :-( (This is due to
335 * missing support for scanning thread-specific data in the
336 * Boehm GC - the io-layer keeps a GC-visible hash of pointers
337 * to TLS data.)
338 */
339 SET_CURRENT_OBJECT (NULL);
340
341 return(0);
342 }
343
344 void mono_thread_new_init (gsize tid, gpointer stack_start, gpointer func)
345 {
346 if (mono_thread_start_cb) {
347 mono_thread_start_cb (tid, stack_start, func);
348 }
349 }
350
351 void mono_threads_set_default_stacksize (guint32 stacksize)
352 {
353 default_stacksize = stacksize;
354 }
355
356 guint32 mono_threads_get_default_stacksize (void)
357 {
358 return default_stacksize;
359 }
360
361 void mono_thread_create (MonoDomain *domain, gpointer func, gpointer arg)
362 {
363 MonoThread *thread;
364 HANDLE thread_handle;
365 struct StartInfo *start_info;
366 gsize tid;
367
368 thread=(MonoThread *)mono_object_new (domain,
369 mono_defaults.thread_class);
370
371 start_info=g_new0 (struct StartInfo, 1);
372 start_info->func = func;
373 start_info->obj = thread;
374 start_info->domain = domain;
375 start_info->start_arg = arg;
376
377 /* Create suspended, so we can do some housekeeping before the thread
378 * starts
379 */
380 thread_handle = CreateThread(NULL, default_stacksize_for_thread (thread), (LPTHREAD_START_ROUTINE)start_wrapper, start_info,
381 CREATE_SUSPENDED, &tid);
382 THREAD_DEBUG (g_message ("%s: Started thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread_handle));
383 if (thread_handle == NULL) {
384 /* The thread couldn't be created, so throw an exception */
385 mono_raise_exception (mono_get_exception_execution_engine ("Couldn't create thread"));
386 return;
387 }
388
389 thread->handle=thread_handle;
390 thread->tid=tid;
391
392 MONO_OBJECT_SETREF (thread, synch_lock, mono_object_new (domain, mono_defaults.object_class));
393
394 handle_store(thread);
395
396 ResumeThread (thread_handle);
397 }
398
399 MonoThread *
400 mono_thread_attach (MonoDomain *domain)
401 {
402 MonoThread *thread;
403 HANDLE thread_handle;
404 gsize tid;
405
406 if ((thread = mono_thread_current ())) {
407 if (domain != mono_domain_get ())
408 mono_domain_set (domain, TRUE);
409 /* Already attached */
410 return thread;
411 }
412
413 if (!mono_gc_register_thread (&domain)) {
414 g_error ("Thread %"G_GSIZE_FORMAT" calling into managed code is not registered with the GC. On UNIX, this can be fixed by #include-ing <gc.h> before <pthread.h> in the file containing the thread creation code.", GetCurrentThreadId ());
415 }
416
417 thread = (MonoThread *)mono_object_new (domain,
418 mono_defaults.thread_class);
419
420 thread_handle = GetCurrentThread ();
421 g_assert (thread_handle);
422
423 tid=GetCurrentThreadId ();
424
425 /*
426 * The handle returned by GetCurrentThread () is a pseudo handle, so it can't be used to
427 * refer to the thread from other threads for things like aborting.
428 */
429 DuplicateHandle (GetCurrentProcess (), thread_handle, GetCurrentProcess (), &thread_handle,
430 THREAD_ALL_ACCESS, TRUE, 0);
431
432 thread->handle=thread_handle;
433 thread->tid=tid;
434 thread->stack_ptr = &tid;
435 MONO_OBJECT_SETREF (thread, synch_lock, mono_object_new (domain, mono_defaults.object_class));
436
437 THREAD_DEBUG (g_message ("%s: Attached thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread_handle));
438
439 handle_store(thread);
440
441 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Setting current_object_key to %p", __func__, GetCurrentThreadId (), thread));
442
443 SET_CURRENT_OBJECT (thread);
444 mono_domain_set (domain, TRUE);
445
446 thread_adjust_static_data (thread);
447
448 if (mono_thread_attach_cb) {
449 mono_thread_attach_cb (tid, &tid);
450 }
451
452 return(thread);
453 }
454
455 void
456 mono_thread_detach (MonoThread *thread)
457 {
458 g_return_if_fail (thread != NULL);
459
460 THREAD_DEBUG (g_message ("%s: mono_thread_detach for %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
461
462 thread_cleanup (thread);
463
464 SET_CURRENT_OBJECT (NULL);
465
466 /* Don't need to CloseHandle this thread, even though we took a
467 * reference in mono_thread_attach (), because the GC will do it
468 * when the Thread object is finalised.
469 */
470 }
471
472 void
473 mono_thread_exit ()
474 {
475 MonoThread *thread = mono_thread_current ();
476
477 thread_cleanup (thread);
478 SET_CURRENT_OBJECT (NULL);
479
480 /* we could add a callback here for embedders to use. */
481 if (thread == mono_thread_get_main ())
482 exit (mono_environment_exitcode_get ());
483 ExitThread (-1);
484 }
485
486 HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this,
487 MonoObject *start)
488 {
489 guint32 (*start_func)(void *);
490 struct StartInfo *start_info;
491 HANDLE thread;
492 gsize tid;
493
494 MONO_ARCH_SAVE_REGS;
495
496 THREAD_DEBUG (g_message("%s: Trying to start a new thread: this (%p) start (%p)", __func__, this, start));
497
498 mono_monitor_enter (this->synch_lock);
499
500 if ((this->state & ThreadState_Unstarted) == 0) {
501 mono_monitor_exit (this->synch_lock);
502 mono_raise_exception (mono_get_exception_thread_state ("Thread has already been started."));
503 return NULL;
504 }
505
506 if ((this->state & ThreadState_Aborted) != 0) {
507 mono_monitor_exit (this->synch_lock);
508 return this;
509 }
510 start_func = NULL;
511 {
512 /* This is freed in start_wrapper */
513 start_info = g_new0 (struct StartInfo, 1);
514 start_info->func = start_func;
515 start_info->start_arg = this->start_obj; /* FIXME: GC object stored in unmanaged memory */
516 start_info->delegate = start;
517 start_info->obj = this;
518 start_info->domain = mono_domain_get ();
519
520 this->start_notify=CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
521 if(this->start_notify==NULL) {
522 mono_monitor_exit (this->synch_lock);
523 g_warning ("%s: CreateSemaphore error 0x%x", __func__, GetLastError ());
524 return(NULL);
525 }
526
527 thread=CreateThread(NULL, default_stacksize_for_thread (this), (LPTHREAD_START_ROUTINE)start_wrapper, start_info,
528 CREATE_SUSPENDED, &tid);
529 if(thread==NULL) {
530 mono_monitor_exit (this->synch_lock);
531 g_warning("%s: CreateThread error 0x%x", __func__, GetLastError());
532 return(NULL);
533 }
534
535 this->handle=thread;
536 this->tid=tid;
537
538 /* Don't call handle_store() here, delay it to Start.
539 * We can't join a thread (trying to will just block
540 * forever) until it actually starts running, so don't
541 * store the handle till then.
542 */
543
544 mono_thread_start (this);
545
546 this->state &= ~ThreadState_Unstarted;
547
548 THREAD_DEBUG (g_message ("%s: Started thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread));
549
550 mono_monitor_exit (this->synch_lock);
551 return(thread);
552 }
553 }
554
555 void ves_icall_System_Threading_Thread_Thread_free_internal (MonoThread *this,
556 HANDLE thread)
557 {
558 MONO_ARCH_SAVE_REGS;
559
560 THREAD_DEBUG (g_message ("%s: Closing thread %p, handle %p", __func__, this, thread));
561
562 CloseHandle (thread);
563 }
564
565 static void mono_thread_start (MonoThread *thread)
566 {
567 MONO_ARCH_SAVE_REGS;
568
569 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Launching thread %p (%"G_GSIZE_FORMAT")", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
570
571 /* Only store the handle when the thread is about to be
572 * launched, to avoid the main thread deadlocking while trying
573 * to clean up a thread that will never be signalled.
574 */
575 handle_store (thread);
576
577 ResumeThread (thread->handle);
578
579 if(thread->start_notify!=NULL) {
580 /* Wait for the thread to set up its TLS data etc, so
581 * theres no potential race condition if someone tries
582 * to look up the data believing the thread has
583 * started
584 */
585
586 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") waiting for thread %p (%"G_GSIZE_FORMAT") to start", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
587
588 WaitForSingleObjectEx (thread->start_notify, INFINITE, FALSE);
589 CloseHandle (thread->start_notify);
590 thread->start_notify = NULL;
591 }
592
593 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Done launching thread %p (%"G_GSIZE_FORMAT")", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
594 }
595
596 void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms)
597 {
598 MonoThread *thread = mono_thread_current ();
599
600 MONO_ARCH_SAVE_REGS;
601
602 THREAD_DEBUG (g_message ("%s: Sleeping for %d ms", __func__, ms));
603
604 mono_thread_current_check_pending_interrupt ();
605
606 mono_monitor_enter (thread->synch_lock);
607 thread->state |= ThreadState_WaitSleepJoin;
608 mono_monitor_exit (thread->synch_lock);
609
610 SleepEx(ms,TRUE);
611
612 mono_monitor_enter (thread->synch_lock);
613 thread->state &= ~ThreadState_WaitSleepJoin;
614 mono_monitor_exit (thread->synch_lock);
615 }
616
617 void ves_icall_System_Threading_Thread_SpinWait_internal (gint32 iterations)
618 {
619 gint32 i;
620
621 for(i = 0; i < iterations; i++) {
622 /* We're busy waiting, but at least we can tell the
623 * scheduler to let someone else have a go...
624 */
625 Sleep (0);
626 }
627 }
628
629 gint32
630 ves_icall_System_Threading_Thread_GetDomainID (void)
631 {
632 MONO_ARCH_SAVE_REGS;
633
634 return mono_domain_get()->domain_id;
635 }
636
637 MonoString*
638 ves_icall_System_Threading_Thread_GetName_internal (MonoThread *this_obj)
639 {
640 MonoString* str;
641 mono_monitor_enter (this_obj->synch_lock);
642
643 if (!this_obj->name)
644 str = NULL;
645 else
646 str = mono_string_new_utf16 (mono_domain_get (), this_obj->name, this_obj->name_len);
647
648 mono_monitor_exit (this_obj->synch_lock);
649 return str;
650 }
651
652 void
653 ves_icall_System_Threading_Thread_SetName_internal (MonoThread *this_obj, MonoString *name)
654 {
655 mono_monitor_enter (this_obj->synch_lock);
656
657 if (this_obj->name) {
658 mono_monitor_exit (this_obj->synch_lock);
659 mono_raise_exception (mono_get_exception_invalid_operation ("Thread.Name can only be set once."));
660 return;
661 }
662 if (name) {
663 this_obj->name = g_new (gunichar2, mono_string_length (name));
664 memcpy (this_obj->name, mono_string_chars (name), mono_string_length (name) * 2);
665 this_obj->name_len = mono_string_length (name);
666 }
667 else
668 this_obj->name = NULL;
669
670 mono_monitor_exit (this_obj->synch_lock);
671 }
672
673 static MonoObject*
674 lookup_cached_culture (MonoThread *this, MonoDomain *domain, int start_idx)
675 {
676 MonoObject *res;
677 int i;
678
679 if (this->cached_culture_info) {
680 domain = mono_domain_get ();
681 for (i = start_idx; i < start_idx + NUM_CACHED_CULTURES; ++i) {
682 res = mono_array_get (this->cached_culture_info, MonoObject*, i);
683 if (res && res->vtable->domain == domain)
684 return res;
685 }
686 }
687
688 return NULL;
689 }
690
691 MonoObject*
692 ves_icall_System_Threading_Thread_GetCachedCurrentCulture (MonoThread *this)
693 {
694 return lookup_cached_culture (this, mono_domain_get (), CULTURES_START_IDX);
695 }
696
697 MonoArray*
698 ves_icall_System_Threading_Thread_GetSerializedCurrentCulture (MonoThread *this)
699 {
700 MonoArray *res;
701
702 mono_monitor_enter (this->synch_lock);
703 if (this->serialized_culture_info) {
704 res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, this->serialized_culture_info_len);
705 memcpy (mono_array_addr (res, guint8, 0), this->serialized_culture_info, this->serialized_culture_info_len);
706 } else {
707 res = NULL;
708 }
709 mono_monitor_exit (this->synch_lock);
710
711 return res;
712 }
713
714 static void
715 cache_culture (MonoThread *this, MonoObject *culture, int start_idx)
716 {
717 int i;
718 MonoDomain *domain = mono_domain_get ();
719 MonoObject *obj;
720 int free_slot = -1;
721 int same_domain_slot = -1;
722
723 mono_monitor_enter (this->synch_lock);
724 if (!this->cached_culture_info)
725 this->cached_culture_info = mono_array_new (mono_object_domain (this), mono_defaults.object_class, NUM_CACHED_CULTURES * 2);
726
727 for (i = start_idx; i < start_idx + NUM_CACHED_CULTURES; ++i) {
728 obj = mono_array_get (this->cached_culture_info, MonoObject*, i);
729 /* Free entry */
730 if (!obj) {
731 free_slot = i;
732 /* we continue, because there may be a slot used with the same domain */
733 continue;
734 }
735 /* Replace */
736 if (obj->vtable->domain == domain) {
737 same_domain_slot = i;
738 break;
739 }
740 }
741 if (same_domain_slot >= 0)
742 mono_array_setref (this->cached_culture_info, same_domain_slot, culture);
743 else if (free_slot >= 0)
744 mono_array_setref (this->cached_culture_info, free_slot, culture);
745 /* we may want to replace an existing entry here, even when no suitable slot is found */
746 mono_monitor_exit (this->synch_lock);
747 }
748
749 void
750 ves_icall_System_Threading_Thread_SetCachedCurrentCulture (MonoThread *this, MonoObject *culture)
751 {
752 cache_culture (this, culture, CULTURES_START_IDX);
753 }
754
755 void
756 ves_icall_System_Threading_Thread_SetSerializedCurrentCulture (MonoThread *this, MonoArray *arr)
757 {
758 mono_monitor_enter (this->synch_lock);
759 if (this->serialized_culture_info)
760 g_free (this->serialized_culture_info);
761 this->serialized_culture_info = g_new0 (guint8, mono_array_length (arr));
762 this->serialized_culture_info_len = mono_array_length (arr);
763 memcpy (this->serialized_culture_info, mono_array_addr (arr, guint8, 0), mono_array_length (arr));
764 mono_monitor_exit (this->synch_lock);
765 }
766
767
768 MonoObject*
769 ves_icall_System_Threading_Thread_GetCachedCurrentUICulture (MonoThread *this)
770 {
771 return lookup_cached_culture (this, mono_domain_get (), UICULTURES_START_IDX);
772 }
773
774 MonoArray*
775 ves_icall_System_Threading_Thread_GetSerializedCurrentUICulture (MonoThread *this)
776 {
777 MonoArray *res;
778
779 mono_monitor_enter (this->synch_lock);
780 if (this->serialized_ui_culture_info) {
781 res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, this->serialized_ui_culture_info_len);
782 memcpy (mono_array_addr (res, guint8, 0), this->serialized_ui_culture_info, this->serialized_ui_culture_info_len);
783 } else {
784 res = NULL;
785 }
786 mono_monitor_exit (this->synch_lock);
787
788 return res;
789 }
790
791 void
792 ves_icall_System_Threading_Thread_SetCachedCurrentUICulture (MonoThread *this, MonoObject *culture)
793 {
794 cache_culture (this, culture, UICULTURES_START_IDX);
795 }
796
797 void
798 ves_icall_System_Threading_Thread_SetSerializedCurrentUICulture (MonoThread *this, MonoArray *arr)
799 {
800 mono_monitor_enter (this->synch_lock);
801 if (this->serialized_ui_culture_info)
802 g_free (this->serialized_ui_culture_info);
803 this->serialized_ui_culture_info = g_new0 (guint8, mono_array_length (arr));
804 this->serialized_ui_culture_info_len = mono_array_length (arr);
805 memcpy (this->serialized_ui_culture_info, mono_array_addr (arr, guint8, 0), mono_array_length (arr));
806 mono_monitor_exit (this->synch_lock);
807 }
808
809 /* the jit may read the compiled code of this function */
810 MonoThread *
811 mono_thread_current (void)
812 {
813 THREAD_DEBUG (g_message ("%s: returning %p", __func__, GET_CURRENT_OBJECT ()));
814 return GET_CURRENT_OBJECT ();
815 }
816
817 gboolean ves_icall_System_Threading_Thread_Join_internal(MonoThread *this,
818 int ms, HANDLE thread)
819 {
820 gboolean ret;
821
822 MONO_ARCH_SAVE_REGS;
823
824 mono_monitor_enter (this->synch_lock);
825
826 if ((this->state & ThreadState_Unstarted) != 0) {
827 mono_monitor_exit (this->synch_lock);
828 mono_raise_exception (mono_get_exception_thread_state ("Thread has not been started."));
829 return FALSE;
830 }
831
832 mono_thread_current_check_pending_interrupt ();
833
834 this->state |= ThreadState_WaitSleepJoin;
835 mono_monitor_exit (this->synch_lock);
836
837 if(ms== -1) {
838 ms=INFINITE;
839 }
840 THREAD_DEBUG (g_message ("%s: joining thread handle %p, %d ms", __func__, thread, ms));
841
842 ret=WaitForSingleObjectEx (thread, ms, TRUE);
843
844 mono_monitor_enter (this->synch_lock);
845 this->state &= ~ThreadState_WaitSleepJoin;
846 mono_monitor_exit (this->synch_lock);
847
848 if(ret==WAIT_OBJECT_0) {
849 THREAD_DEBUG (g_message ("%s: join successful", __func__));
850
851 return(TRUE);
852 }
853
854 THREAD_DEBUG (g_message ("%s: join failed", __func__));
855
856 return(FALSE);
857 }
858
859 /* FIXME: exitContext isnt documented */
860 gboolean ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
861 {
862 HANDLE *handles;
863 guint32 numhandles;
864 guint32 ret;
865 guint32 i;
866 MonoObject *waitHandle;
867 MonoClass *klass;
868 MonoThread *thread = mono_thread_current ();
869
870 MONO_ARCH_SAVE_REGS;
871
872 /* Do this WaitSleepJoin check before creating objects */
873 mono_thread_current_check_pending_interrupt ();
874
875 numhandles = mono_array_length(mono_handles);
876 handles = g_new0(HANDLE, numhandles);
877
878 if (wait_handle_os_handle_field == 0) {
879 /* Get the field os_handle which will contain the actual handle */
880 klass = mono_class_from_name(mono_defaults.corlib, "System.Threading", "WaitHandle");
881 wait_handle_os_handle_field = mono_class_get_field_from_name(klass, "os_handle");
882 }
883
884 for(i = 0; i < numhandles; i++) {
885 waitHandle = mono_array_get(mono_handles, MonoObject*, i);
886 mono_field_get_value(waitHandle, wait_handle_os_handle_field, &handles[i]);
887 }
888
889 if(ms== -1) {
890 ms=INFINITE;
891 }
892
893 mono_monitor_enter (thread->synch_lock);
894 thread->state |= ThreadState_WaitSleepJoin;
895 mono_monitor_exit (thread->synch_lock);
896
897 ret=WaitForMultipleObjectsEx(numhandles, handles, TRUE, ms, TRUE);
898
899 mono_monitor_enter (thread->synch_lock);
900 thread->state &= ~ThreadState_WaitSleepJoin;
901 mono_monitor_exit (thread->synch_lock);
902
903 g_free(handles);
904
905 if(ret==WAIT_FAILED) {
906 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait failed", __func__, GetCurrentThreadId ()));
907 return(FALSE);
908 } else if(ret==WAIT_TIMEOUT || ret == WAIT_IO_COMPLETION) {
909 /* Do we want to try again if we get
910 * WAIT_IO_COMPLETION? The documentation for
911 * WaitHandle doesn't give any clues. (We'd have to
912 * fiddle with the timeout if we retry.)
913 */
914 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait timed out", __func__, GetCurrentThreadId ()));
915 return(FALSE);
916 }
917
918 return(TRUE);
919 }
920
921 /* FIXME: exitContext isnt documented */
922 gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
923 {
924 HANDLE *handles;
925 guint32 numhandles;
926 guint32 ret;
927 guint32 i;
928 MonoObject *waitHandle;
929 MonoClass *klass;
930 MonoThread *thread = mono_thread_current ();
931
932 MONO_ARCH_SAVE_REGS;
933
934 /* Do this WaitSleepJoin check before creating objects */
935 mono_thread_current_check_pending_interrupt ();
936
937 numhandles = mono_array_length(mono_handles);
938 handles = g_new0(HANDLE, numhandles);
939
940 if (wait_handle_os_handle_field == 0) {
941 /* Get the field os_handle which will contain the actual handle */
942 klass = mono_class_from_name(mono_defaults.corlib, "System.Threading", "WaitHandle");
943 wait_handle_os_handle_field = mono_class_get_field_from_name(klass, "os_handle");
944 }
945
946 for(i = 0; i < numhandles; i++) {
947 waitHandle = mono_array_get(mono_handles, MonoObject*, i);
948 mono_field_get_value(waitHandle, wait_handle_os_handle_field, &handles[i]);
949 }
950
951 if(ms== -1) {
952 ms=INFINITE;
953 }
954
955 mono_monitor_enter (thread->synch_lock);
956 thread->state |= ThreadState_WaitSleepJoin;
957 mono_monitor_exit (thread->synch_lock);
958
959 ret=WaitForMultipleObjectsEx(numhandles, handles, FALSE, ms, TRUE);
960
961 mono_monitor_enter (thread->synch_lock);
962 thread->state &= ~ThreadState_WaitSleepJoin;
963 mono_monitor_exit (thread->synch_lock);
964
965 g_free(handles);
966
967 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") returning %d", __func__, GetCurrentThreadId (), ret));
968
969 /*
970 * These need to be here. See MSDN dos on WaitForMultipleObjects.
971 */
972 if (ret >= WAIT_OBJECT_0 && ret <= WAIT_OBJECT_0 + numhandles - 1) {
973 return ret - WAIT_OBJECT_0;
974 }
975 else if (ret >= WAIT_ABANDONED_0 && ret <= WAIT_ABANDONED_0 + numhandles - 1) {
976 return ret - WAIT_ABANDONED_0;
977 }
978 else {
979 return ret;
980 }
981 }
982
983 /* FIXME: exitContext isnt documented */
984 gboolean ves_icall_System_Threading_WaitHandle_WaitOne_internal(MonoObject *this, HANDLE handle, gint32 ms, gboolean exitContext)
985 {
986 guint32 ret;
987 MonoThread *thread = mono_thread_current ();
988
989 MONO_ARCH_SAVE_REGS;
990
991 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") waiting for %p, %d ms", __func__, GetCurrentThreadId (), handle, ms));
992
993 if(ms== -1) {
994 ms=INFINITE;
995 }
996
997 mono_thread_current_check_pending_interrupt ();
998
999 mono_monitor_enter (thread->synch_lock);
1000 thread->state |= ThreadState_WaitSleepJoin;
1001 mono_monitor_exit (thread->synch_lock);
1002
1003 ret=WaitForSingleObjectEx (handle, ms, TRUE);
1004
1005 mono_monitor_enter (thread->synch_lock);
1006 thread->state &= ~ThreadState_WaitSleepJoin;
1007 mono_monitor_exit (thread->synch_lock);
1008
1009 if(ret==WAIT_FAILED) {
1010 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait failed", __func__, GetCurrentThreadId ()));
1011 return(FALSE);
1012 } else if(ret==WAIT_TIMEOUT || ret == WAIT_IO_COMPLETION) {
1013 /* Do we want to try again if we get
1014 * WAIT_IO_COMPLETION? The documentation for
1015 * WaitHandle doesn't give any clues. (We'd have to
1016 * fiddle with the timeout if we retry.)
1017 */
1018 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait timed out", __func__, GetCurrentThreadId ()));
1019 return(FALSE);
1020 }
1021
1022 return(TRUE);
1023 }
1024
1025 HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned, MonoString *name, MonoBoolean *created)
1026 {
1027 HANDLE mutex;
1028
1029 MONO_ARCH_SAVE_REGS;
1030
1031 *created = TRUE;
1032
1033 if (name == NULL) {
1034 mutex = CreateMutex (NULL, owned, NULL);
1035 } else {
1036 mutex = CreateMutex (NULL, owned, mono_string_chars (name));
1037
1038 if (GetLastError () == ERROR_ALREADY_EXISTS) {
1039 *created = FALSE;
1040 }
1041 }
1042
1043 return(mutex);
1044 }
1045
1046 void ves_icall_System_Threading_Mutex_ReleaseMutex_internal (HANDLE handle ) {
1047 MONO_ARCH_SAVE_REGS;
1048
1049 ReleaseMutex(handle);
1050 }
1051
1052 HANDLE ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoString *name,
1053 gint32 rights,
1054 gint32 *error)
1055 {
1056 HANDLE ret;
1057
1058 MONO_ARCH_SAVE_REGS;
1059
1060 *error = ERROR_SUCCESS;
1061
1062 ret = OpenMutex (rights, FALSE, mono_string_chars (name));
1063 if (ret == NULL) {
1064 *error = GetLastError ();
1065 }
1066
1067 return(ret);
1068 }
1069
1070
1071 HANDLE ves_icall_System_Threading_Semaphore_CreateSemaphore_internal (gint32 initialCount, gint32 maximumCount, MonoString *name, MonoBoolean *created)
1072 {
1073 HANDLE sem;
1074
1075 MONO_ARCH_SAVE_REGS;
1076
1077 *created = TRUE;
1078
1079 if (name == NULL) {
1080 sem = CreateSemaphore (NULL, initialCount, maximumCount, NULL);
1081 } else {
1082 sem = CreateSemaphore (NULL, initialCount, maximumCount,
1083 mono_string_chars (name));
1084
1085 if (GetLastError () == ERROR_ALREADY_EXISTS) {
1086 *created = FALSE;
1087 }
1088 }
1089
1090 return(sem);
1091 }
1092
1093 gint32 ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal (HANDLE handle, gint32 releaseCount, MonoBoolean *fail)
1094 {
1095 gint32 prevcount;
1096
1097 MONO_ARCH_SAVE_REGS;
1098
1099 *fail = !ReleaseSemaphore (handle, releaseCount, &prevcount);
1100
1101 return (prevcount);
1102 }
1103
1104 HANDLE ves_icall_System_Threading_Semaphore_OpenSemaphore_internal (MonoString *name, gint32 rights, gint32 *error)
1105 {
1106 HANDLE ret;
1107
1108 MONO_ARCH_SAVE_REGS;
1109
1110 *error = ERROR_SUCCESS;
1111
1112 ret = OpenSemaphore (rights, FALSE, mono_string_chars (name));
1113 if (ret == NULL) {
1114 *error = GetLastError ();
1115 }
1116
1117 return(ret);
1118 }
1119
1120 HANDLE ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoString *name, MonoBoolean *created)
1121 {
1122 HANDLE event;
1123
1124 MONO_ARCH_SAVE_REGS;
1125
1126 *created = TRUE;
1127
1128 if (name == NULL) {
1129 event = CreateEvent (NULL, manual, initial, NULL);
1130 } else {
1131 event = CreateEvent (NULL, manual, initial,
1132 mono_string_chars (name));
1133
1134 if (GetLastError () == ERROR_ALREADY_EXISTS) {
1135 *created = FALSE;
1136 }
1137 }
1138
1139 return(event);
1140 }
1141
1142 gboolean ves_icall_System_Threading_Events_SetEvent_internal (HANDLE handle) {
1143 MONO_ARCH_SAVE_REGS;
1144
1145 return (SetEvent(handle));
1146 }
1147
1148 gboolean ves_icall_System_Threading_Events_ResetEvent_internal (HANDLE handle) {
1149 MONO_ARCH_SAVE_REGS;
1150
1151 return (ResetEvent(handle));
1152 }
1153
1154 void
1155 ves_icall_System_Threading_Events_CloseEvent_internal (HANDLE handle) {
1156 MONO_ARCH_SAVE_REGS;
1157
1158 CloseHandle (handle);
1159 }
1160
1161 HANDLE ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name,
1162 gint32 rights,
1163 gint32 *error)
1164 {
1165 HANDLE ret;
1166
1167 MONO_ARCH_SAVE_REGS;
1168
1169 *error = ERROR_SUCCESS;
1170
1171 ret = OpenEvent (rights, FALSE, mono_string_chars (name));
1172 if (ret == NULL) {
1173 *error = GetLastError ();
1174 }
1175
1176 return(ret);
1177 }
1178
1179 gint32 ves_icall_System_Threading_Interlocked_Increment_Int (gint32 *location)
1180 {
1181 MONO_ARCH_SAVE_REGS;
1182
1183 return InterlockedIncrement (location);
1184 }
1185
1186 gint64 ves_icall_System_Threading_Interlocked_Increment_Long (gint64 *location)
1187 {
1188 gint64 ret;
1189
1190 MONO_ARCH_SAVE_REGS;
1191
1192 mono_interlocked_lock ();
1193
1194 ret = ++ *location;
1195
1196 mono_interlocked_unlock ();
1197
1198
1199 return ret;
1200 }
1201
1202 gint32 ves_icall_System_Threading_Interlocked_Decrement_Int (gint32 *location)
1203 {
1204 MONO_ARCH_SAVE_REGS;
1205
1206 return InterlockedDecrement(location);
1207 }
1208
1209 gint64 ves_icall_System_Threading_Interlocked_Decrement_Long (gint64 * location)
1210 {
1211 gint64 ret;
1212
1213 MONO_ARCH_SAVE_REGS;
1214
1215 mono_interlocked_lock ();
1216
1217 ret = -- *location;
1218
1219 mono_interlocked_unlock ();
1220
1221 return ret;
1222 }
1223
1224 gint32 ves_icall_System_Threading_Interlocked_Exchange_Int (gint32 *location, gint32 value)
1225 {
1226 MONO_ARCH_SAVE_REGS;
1227
1228 return InterlockedExchange(location, value);
1229 }
1230
1231 MonoObject * ves_icall_System_Threading_Interlocked_Exchange_Object (MonoObject **location, MonoObject *value)
1232 {
1233 MONO_ARCH_SAVE_REGS;
1234
1235 return (MonoObject *) InterlockedExchangePointer((gpointer *) location, value);
1236 }
1237
1238 gfloat ves_icall_System_Threading_Interlocked_Exchange_Single (gfloat *location, gfloat value)
1239 {
1240 IntFloatUnion val, ret;
1241
1242 MONO_ARCH_SAVE_REGS;
1243
1244 val.fval = value;
1245 ret.ival = InterlockedExchange((gint32 *) location, val.ival);
1246
1247 return ret.fval;
1248 }
1249
1250 gint64
1251 ves_icall_System_Threading_Interlocked_Exchange_Long (gint64 *location, gint64 value)
1252 {
1253 #if SIZEOF_VOID_P == 8
1254 return (gint64) InterlockedExchangePointer((gpointer *) location, (gpointer)value);
1255 #else
1256 gint64 res;
1257
1258 /*
1259 * According to MSDN, this function is only atomic with regards to the
1260 * other Interlocked functions on 32 bit platforms.
1261 */
1262 mono_interlocked_lock ();
1263 res = *location;
1264 *location = value;
1265 mono_interlocked_unlock ();
1266
1267 return res;
1268 #endif
1269 }
1270
1271 gdouble
1272 ves_icall_System_Threading_Interlocked_Exchange_Double (gdouble *location, gdouble value)
1273 {
1274 #if SIZEOF_VOID_P == 8
1275 LongDoubleUnion val, ret;
1276
1277 val.fval = value;
1278 ret.ival = (gint64)InterlockedExchangePointer((gpointer *) location, (gpointer)val.ival);
1279
1280 return ret.fval;
1281 #else
1282 gdouble res;
1283
1284 /*
1285 * According to MSDN, this function is only atomic with regards to the
1286 * other Interlocked functions on 32 bit platforms.
1287 */
1288 mono_interlocked_lock ();
1289 res = *location;
1290 *location = value;
1291 mono_interlocked_unlock ();
1292
1293 return res;
1294 #endif
1295 }
1296
1297 gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand)
1298 {
1299 MONO_ARCH_SAVE_REGS;
1300
1301 return InterlockedCompareExchange(location, value, comparand);
1302 }
1303
1304 MonoObject * ves_icall_System_Threading_Interlocked_CompareExchange_Object (MonoObject **location, MonoObject *value, MonoObject *comparand)
1305 {
1306 MONO_ARCH_SAVE_REGS;
1307
1308 return (MonoObject *) InterlockedCompareExchangePointer((gpointer *) location, value, comparand);
1309 }
1310
1311 gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single (gfloat *location, gfloat value, gfloat comparand)
1312 {
1313 IntFloatUnion val, ret, cmp;
1314
1315 MONO_ARCH_SAVE_REGS;
1316
1317 val.fval = value;
1318 cmp.fval = comparand;
1319 ret.ival = InterlockedCompareExchange((gint32 *) location, val.ival, cmp.ival);
1320
1321 return ret.fval;
1322 }
1323
1324 gdouble
1325 ves_icall_System_Threading_Interlocked_CompareExchange_Double (gdouble *location, gdouble value, gdouble comparand)
1326 {
1327 #if SIZEOF_VOID_P == 8
1328 LongDoubleUnion val, comp, ret;
1329
1330 val.fval = value;
1331 comp.fval = comparand;
1332 ret.ival = (gint64)InterlockedCompareExchangePointer((gpointer *) location, (gpointer)val.ival, (gpointer)comp.ival);
1333
1334 return ret.fval;
1335 #else
1336 gdouble old;
1337
1338 mono_interlocked_lock ();
1339 old = *location;
1340 if (old == comparand)
1341 *location = value;
1342 mono_interlocked_unlock ();
1343
1344 return old;
1345 #endif
1346 }
1347
1348 gint64
1349 ves_icall_System_Threading_Interlocked_CompareExchange_Long (gint64 *location, gint64 value, gint64 comparand)
1350 {
1351 #if SIZEOF_VOID_P == 8
1352 return (gint64)InterlockedCompareExchangePointer((gpointer *) location, (gpointer)value, (gpointer)comparand);
1353 #else
1354 gint64 old;
1355
1356 mono_interlocked_lock ();
1357 old = *location;
1358 if (old == comparand)
1359 *location = value;
1360 mono_interlocked_unlock ();
1361
1362 return old;
1363 #endif
1364 }
1365
1366 MonoObject*
1367 ves_icall_System_Threading_Interlocked_CompareExchange_T (MonoObject **location, MonoObject *value, MonoObject *comparand)
1368 {
1369 MONO_ARCH_SAVE_REGS;
1370
1371 return InterlockedCompareExchangePointer ((gpointer *)location, value, comparand);
1372 }
1373
1374 MonoObject*
1375 ves_icall_System_Threading_Interlocked_Exchange_T (MonoObject **location, MonoObject *value)
1376 {
1377 MONO_ARCH_SAVE_REGS;
1378
1379 return InterlockedExchangePointer ((gpointer *)location, value);
1380 }
1381
1382 gint32
1383 ves_icall_System_Threading_Interlocked_Add_Int (gint32 *location, gint32 value)
1384 {
1385 #if SIZEOF_VOID_P == 8
1386 /* Should be implemented as a JIT intrinsic */
1387 mono_raise_exception (mono_get_exception_not_implemented (NULL));
1388 return 0;
1389 #else
1390 gint32 orig;
1391
1392 mono_interlocked_lock ();
1393 orig = *location;
1394 *location = orig + value;
1395 mono_interlocked_unlock ();
1396
1397 return orig + value;
1398 #endif
1399 }
1400
1401 gint64
1402 ves_icall_System_Threading_Interlocked_Add_Long (gint64 *location, gint64 value)
1403 {
1404 #if SIZEOF_VOID_P == 8
1405 /* Should be implemented as a JIT intrinsic */
1406 mono_raise_exception (mono_get_exception_not_implemented (NULL));
1407 return 0;
1408 #else
1409 gint64 orig;
1410
1411 mono_interlocked_lock ();
1412 orig = *location;
1413 *location = orig + value;
1414 mono_interlocked_unlock ();
1415
1416 return orig + value;
1417 #endif
1418 }
1419
1420 gint64
1421 ves_icall_System_Threading_Interlocked_Read_Long (gint64 *location)
1422 {
1423 #if SIZEOF_VOID_P == 8
1424 /* 64 bit reads are already atomic */
1425 return *location;
1426 #else
1427 gint64 res;
1428
1429 mono_interlocked_lock ();
1430 res = *location;
1431 mono_interlocked_unlock ();
1432
1433 return res;
1434 #endif
1435 }
1436
1437 void
1438 ves_icall_System_Threading_Thread_MemoryBarrier (void)
1439 {
1440 /* Should be implemented as a JIT intrinsic */
1441 mono_raise_exception (mono_get_exception_not_implemented (NULL));
1442 }
1443
1444 void
1445 ves_icall_System_Threading_Thread_ClrState (MonoThread* this, guint32 state)
1446 {
1447 mono_monitor_enter (this->synch_lock);
1448 this->state &= ~state;
1449 if (state & ThreadState_Background) {
1450 /* If the thread changes the background mode, the main thread has to
1451 * be notified, since it has to rebuild the list of threads to
1452 * wait for.
1453 */
1454 SetEvent (background_change_event);
1455 }
1456 mono_monitor_exit (this->synch_lock);
1457 }
1458
1459 void
1460 ves_icall_System_Threading_Thread_SetState (MonoThread* this, guint32 state)
1461 {
1462 mono_monitor_enter (this->synch_lock);
1463 this->state |= state;
1464 if (state & ThreadState_Background) {
1465 /* If the thread changes the background mode, the main thread has to
1466 * be notified, since it has to rebuild the list of threads to
1467 * wait for.
1468 */
1469 SetEvent (background_change_event);
1470 }
1471 mono_monitor_exit (this->synch_lock);
1472 }
1473
1474 guint32
1475 ves_icall_System_Threading_Thread_GetState (MonoThread* this)
1476 {
1477 guint32 state;
1478 mono_monitor_enter (this->synch_lock);
1479 state = this->state;
1480 mono_monitor_exit (this->synch_lock);
1481 return state;
1482 }
1483
1484 void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this)
1485 {
1486 gboolean throw = FALSE;
1487
1488 mono_monitor_enter (this->synch_lock);
1489
1490 /* Clear out any previous request */
1491 this->thread_interrupt_requested = FALSE;
1492
1493 if (this->state & ThreadState_WaitSleepJoin) {
1494 throw = TRUE;
1495 } else {
1496 this->thread_interrupt_requested = TRUE;
1497 }
1498
1499 mono_monitor_exit (this->synch_lock);
1500
1501 if (throw) {
1502 signal_thread_state_change (this);
1503 }
1504 }
1505
1506 void mono_thread_current_check_pending_interrupt ()
1507 {
1508 MonoThread *thread = mono_thread_current ();
1509 gboolean throw = FALSE;
1510
1511 mono_monitor_enter (thread->synch_lock);
1512
1513 if (thread->thread_interrupt_requested) {
1514 throw = TRUE;
1515 thread->thread_interrupt_requested = FALSE;
1516 }
1517
1518 mono_monitor_exit (thread->synch_lock);
1519
1520 if (throw) {
1521 mono_raise_exception (mono_get_exception_thread_interrupted ());
1522 }
1523 }
1524
1525 int
1526 mono_thread_get_abort_signal (void)
1527 {
1528 #if defined (__MINGW32__) || defined (_MSC_VER)
1529 return -1;
1530 #else
1531 #ifndef SIGRTMIN
1532 return SIGUSR1;
1533 #else
1534 static int abort_signum = -1;
1535 int i;
1536 if (abort_signum != -1)
1537 return abort_signum;
1538 /* we try to avoid SIGRTMIN and any one that might have been set already, see bug #75387 */
1539 for (i = SIGRTMIN + 1; i < SIGRTMAX; ++i) {
1540 struct sigaction sinfo;
1541 sigaction (i, NULL, &sinfo);
1542 if (sinfo.sa_handler == SIG_DFL && (void*)sinfo.sa_sigaction == (void*)SIG_DFL) {
1543 abort_signum = i;
1544 return i;
1545 }
1546 }
1547 /* fallback to the old way */
1548 return SIGRTMIN;
1549 #endif
1550 #endif /*defined (__MINGW32__) || defined (_MSC_VER) */
1551 }
1552
1553 #if defined (__MINGW32__) || defined (_MSC_VER)
1554 static void CALLBACK interruption_request_apc (ULONG_PTR param)
1555 {
1556 MonoException* exc = mono_thread_request_interruption (FALSE);
1557 if (exc) mono_raise_exception (exc);
1558 }
1559 #endif /* defined (__MINGW32__) || defined (_MSC_VER) */
1560
1561 /*
1562 * signal_thread_state_change
1563 *
1564 * Tells the thread that his state has changed and it has to enter the new
1565 * state as soon as possible.
1566 */
1567 static void signal_thread_state_change (MonoThread *thread)
1568 {
1569 if (thread == mono_thread_current ()) {
1570 /* Do it synchronously */
1571 MonoException *exc = mono_thread_request_interruption (FALSE);
1572 if (exc)
1573 mono_raise_exception (exc);
1574 }
1575
1576 #if defined (__MINGW32__) || defined (_MSC_VER)
1577 QueueUserAPC ((PAPCFUNC)interruption_request_apc, thread->handle, NULL);
1578 #else
1579 /* fixme: store the state somewhere */
1580 #ifdef PTHREAD_POINTER_ID
1581 pthread_kill ((gpointer)(gsize)(thread->tid), mono_thread_get_abort_signal ());
1582 #else
1583 pthread_kill (thread->tid, mono_thread_get_abort_signal ());
1584 #endif
1585 #endif /* defined (__MINGW32__) || defined (__MSC_VER) */
1586 }
1587
1588 void
1589 ves_icall_System_Threading_Thread_Abort (MonoThread *thread, MonoObject *state)
1590 {
1591 MONO_ARCH_SAVE_REGS;
1592
1593 mono_monitor_enter (thread->synch_lock);
1594
1595 if ((thread->state & ThreadState_AbortRequested) != 0 ||
1596 (thread->state & ThreadState_StopRequested) != 0 ||
1597 (thread->state & ThreadState_Stopped) != 0)
1598 {
1599 mono_monitor_exit (thread->synch_lock);
1600 return;
1601 }
1602
1603 if ((thread->state & ThreadState_Unstarted) != 0) {
1604 thread->state |= ThreadState_Aborted;
1605 mono_monitor_exit (thread->synch_lock);
1606 return;
1607 }
1608
1609 thread->state |= ThreadState_AbortRequested;
1610 MONO_OBJECT_SETREF (thread, abort_state, state);
1611 thread->abort_exc = NULL;
1612
1613 mono_monitor_exit (thread->synch_lock);
1614
1615 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Abort requested for %p (%"G_GSIZE_FORMAT")", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
1616
1617 /* Make sure the thread is awake */
1618 mono_thread_resume (thread);
1619
1620 signal_thread_state_change (thread);
1621 }
1622
1623 void
1624 ves_icall_System_Threading_Thread_ResetAbort (void)
1625 {
1626 MonoThread *thread = mono_thread_current ();
1627
1628 MONO_ARCH_SAVE_REGS;
1629
1630 mono_monitor_enter (thread->synch_lock);
1631
1632 thread->state &= ~ThreadState_AbortRequested;
1633
1634 if (!thread->abort_exc) {
1635 const char *msg = "Unable to reset abort because no abort was requested";
1636 mono_monitor_exit (thread->synch_lock);
1637 mono_raise_exception (mono_get_exception_thread_state (msg));
1638 } else {
1639 thread->abort_exc = NULL;
1640 thread->abort_state = NULL;
1641 }
1642
1643 mono_monitor_exit (thread->synch_lock);
1644 }
1645
1646 static gboolean
1647 mono_thread_suspend (MonoThread *thread)
1648 {
1649 MONO_ARCH_SAVE_REGS;
1650
1651 mono_monitor_enter (thread->synch_lock);
1652
1653 if ((thread->state & ThreadState_Unstarted) != 0 ||
1654 (thread->state & ThreadState_Aborted) != 0 ||
1655 (thread->state & ThreadState_Stopped) != 0)
1656 {
1657 mono_monitor_exit (thread->synch_lock);
1658 return FALSE;
1659 }
1660
1661 if ((thread->state & ThreadState_Suspended) != 0 ||
1662 (thread->state & ThreadState_SuspendRequested) != 0 ||
1663 (thread->state & ThreadState_StopRequested) != 0)
1664 {
1665 mono_monitor_exit (thread->synch_lock);
1666 return TRUE;
1667 }
1668
1669 thread->state |= ThreadState_SuspendRequested;
1670 mono_monitor_exit (thread->synch_lock);
1671
1672 signal_thread_state_change (thread);
1673 return TRUE;
1674 }
1675
1676 void
1677 ves_icall_System_Threading_Thread_Suspend (MonoThread *thread)
1678 {
1679 if (!mono_thread_suspend (thread))
1680 mono_raise_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
1681 }
1682
1683 static gboolean
1684 mono_thread_resume (MonoThread *thread)
1685 {
1686 MONO_ARCH_SAVE_REGS;
1687
1688 mono_monitor_enter (thread->synch_lock);
1689
1690 if ((thread->state & ThreadState_SuspendRequested) != 0) {
1691 thread->state &= ~ThreadState_SuspendRequested;
1692 mono_monitor_exit (thread->synch_lock);
1693 return TRUE;
1694 }
1695
1696 if ((thread->state & ThreadState_Suspended) == 0 ||
1697 (thread->state & ThreadState_Unstarted) != 0 ||
1698 (thread->state & ThreadState_Aborted) != 0 ||
1699 (thread->state & ThreadState_Stopped) != 0)
1700 {
1701 mono_monitor_exit (thread->synch_lock);
1702 return FALSE;
1703 }
1704
1705 thread->resume_event = CreateEvent (NULL, TRUE, FALSE, NULL);
1706 if (thread->resume_event == NULL) {
1707 mono_monitor_exit (thread->synch_lock);
1708 return(FALSE);
1709 }
1710
1711 /* Awake the thread */
1712 SetEvent (thread->suspend_event);
1713
1714 mono_monitor_exit (thread->synch_lock);
1715
1716 /* Wait for the thread to awake */
1717 WaitForSingleObject (thread->resume_event, INFINITE);
1718 CloseHandle (thread->resume_event);
1719 thread->resume_event = NULL;
1720
1721 return TRUE;
1722 }
1723
1724 void
1725 ves_icall_System_Threading_Thread_Resume (MonoThread *thread)
1726 {
1727 if (!mono_thread_resume (thread))
1728 mono_raise_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
1729 }
1730
1731 static gboolean
1732 find_wrapper (MonoMethod *m, gint no, gint ilo, gboolean managed, gpointer data)
1733 {
1734 if (managed)
1735 return TRUE;
1736
1737 if (m->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
1738 m->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
1739 m->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH)
1740 {
1741 *((gboolean*)data) = TRUE;
1742 return TRUE;
1743 }
1744 return FALSE;
1745 }
1746
1747 static gboolean
1748 is_running_protected_wrapper (void)
1749 {
1750 gboolean found = FALSE;
1751 mono_stack_walk (find_wrapper, &found);
1752 return found;
1753 }
1754
1755 void mono_thread_stop (MonoThread *thread)
1756 {
1757 mono_monitor_enter (thread->synch_lock);
1758
1759 if ((thread->state & ThreadState_StopRequested) != 0 ||
1760 (thread->state & ThreadState_Stopped) != 0)
1761 {
1762 mono_monitor_exit (thread->synch_lock);
1763 return;
1764 }
1765
1766 /* Make sure the thread is awake */
1767 mono_thread_resume (thread);
1768
1769 thread->state |= ThreadState_StopRequested;
1770 thread->state &= ~ThreadState_AbortRequested;
1771
1772 mono_monitor_exit (thread->synch_lock);
1773
1774 signal_thread_state_change (thread);
1775 }
1776
1777 gint8
1778 ves_icall_System_Threading_Thread_VolatileRead1 (void *ptr)
1779 {
1780 return *((volatile gint8 *) (ptr));
1781 }
1782
1783 gint16
1784 ves_icall_System_Threading_Thread_VolatileRead2 (void *ptr)
1785 {
1786 return *((volatile gint16 *) (ptr));
1787 }
1788
1789 gint32
1790 ves_icall_System_Threading_Thread_VolatileRead4 (void *ptr)
1791 {
1792 return *((volatile gint32 *) (ptr));
1793 }
1794
1795 gint64
1796 ves_icall_System_Threading_Thread_VolatileRead8 (void *ptr)
1797 {
1798 return *((volatile gint64 *) (ptr));
1799 }
1800
1801 void *
1802 ves_icall_System_Threading_Thread_VolatileReadIntPtr (void *ptr)
1803 {
1804 return (void *) *((volatile void **) ptr);
1805 }
1806
1807 void
1808 ves_icall_System_Threading_Thread_VolatileWrite1 (void *ptr, gint8 value)
1809 {
1810 *((volatile gint8 *) ptr) = value;
1811 }
1812
1813 void
1814 ves_icall_System_Threading_Thread_VolatileWrite2 (void *ptr, gint16 value)
1815 {
1816 *((volatile gint16 *) ptr) = value;
1817 }
1818
1819 void
1820 ves_icall_System_Threading_Thread_VolatileWrite4 (void *ptr, gint32 value)
1821 {
1822 *((volatile gint32 *) ptr) = value;
1823 }
1824
1825 void
1826 ves_icall_System_Threading_Thread_VolatileWrite8 (void *ptr, gint64 value)
1827 {
1828 *((volatile gint64 *) ptr) = value;
1829 }
1830
1831 void
1832 ves_icall_System_Threading_Thread_VolatileWriteIntPtr (void *ptr, void *value)
1833 {
1834 *((volatile void **) ptr) = value;
1835 }
1836
1837 void mono_thread_init (MonoThreadStartCB start_cb,
1838 MonoThreadAttachCB attach_cb)
1839 {
1840 InitializeCriticalSection(&threads_mutex);
1841 InitializeCriticalSection(&interlocked_mutex);
1842 InitializeCriticalSection(&contexts_mutex);
1843 background_change_event = CreateEvent (NULL, TRUE, FALSE, NULL);
1844 g_assert(background_change_event != NULL);
1845
1846 mono_init_static_data_info (&thread_static_info);
1847 mono_init_static_data_info (&context_static_info);
1848
1849 current_object_key=TlsAlloc();
1850 THREAD_DEBUG (g_message ("%s: Allocated current_object_key %d", __func__, current_object_key));
1851
1852 mono_thread_start_cb = start_cb;
1853 mono_thread_attach_cb = attach_cb;
1854
1855 /* Get a pseudo handle to the current process. This is just a
1856 * kludge so that wapi can build a process handle if needed.
1857 * As a pseudo handle is returned, we don't need to clean
1858 * anything up.
1859 */
1860 GetCurrentProcess ();
1861 }
1862
1863 void mono_thread_cleanup (void)
1864 {
1865 #if !defined(PLATFORM_WIN32) && !defined(RUN_IN_SUBTHREAD)
1866 /* The main thread must abandon any held mutexes (particularly
1867 * important for named mutexes as they are shared across
1868 * processes, see bug 74680.) This will happen when the
1869 * thread exits, but if it's not running in a subthread it
1870 * won't exit in time.
1871 */
1872 /* Using non-w32 API is a nasty kludge, but I couldn't find
1873 * anything in the documentation that would let me do this
1874 * here yet still be safe to call on windows.
1875 */
1876 _wapi_thread_signal_self (mono_environment_exitcode_get ());
1877 #endif
1878
1879 #if 0
1880 /* This stuff needs more testing, it seems one of these
1881 * critical sections can be locked when mono_thread_cleanup is
1882 * called.
1883 */
1884 DeleteCriticalSection (&threads_mutex);
1885 DeleteCriticalSection (&interlocked_mutex);
1886 DeleteCriticalSection (&contexts_mutex);
1887 CloseHandle (background_change_event);
1888 #endif
1889
1890 TlsFree (current_object_key);
1891 }
1892
1893 void
1894 mono_threads_install_cleanup (MonoThreadCleanupFunc func)
1895 {
1896 mono_thread_cleanup_fn = func;
1897 }
1898
1899 G_GNUC_UNUSED
1900 static void print_tids (gpointer key, gpointer value, gpointer user)
1901 {
1902 /* GPOINTER_TO_UINT breaks horribly if sizeof(void *) >
1903 * sizeof(uint) and a cast to uint would overflow
1904 */
1905 /* Older versions of glib don't have G_GSIZE_FORMAT, so just
1906 * print this as a pointer.
1907 */
1908 g_message ("Waiting for: %p", key);
1909 }
1910
1911 struct wait_data
1912 {
1913 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
1914 MonoThread *threads[MAXIMUM_WAIT_OBJECTS];
1915 guint32 num;
1916 };
1917
1918 static void wait_for_tids (struct wait_data *wait, guint32 timeout)
1919 {
1920 guint32 i, ret;
1921
1922 THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
1923
1924 ret=WaitForMultipleObjectsEx(wait->num, wait->handles, TRUE, timeout, FALSE);
1925
1926 if(ret==WAIT_FAILED) {
1927 /* See the comment in build_wait_tids() */
1928 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
1929 return;
1930 }
1931
1932 for(i=0; i<wait->num; i++)
1933 CloseHandle (wait->handles[i]);
1934
1935 if (ret == WAIT_TIMEOUT)
1936 return;
1937
1938 for(i=0; i<wait->num; i++) {
1939 gsize tid = wait->threads[i]->tid;
1940
1941 if(mono_g_hash_table_lookup (threads, (gpointer)tid)!=NULL) {
1942 /* This thread must have been killed, because
1943 * it hasn't cleaned itself up. (It's just
1944 * possible that the thread exited before the
1945 * parent thread had a chance to store the
1946 * handle, and now there is another pointer to
1947 * the already-exited thread stored. In this
1948 * case, we'll just get two
1949 * mono_profiler_thread_end() calls for the
1950 * same thread.)
1951 */
1952
1953 THREAD_DEBUG (g_message ("%s: cleaning up after thread %"G_GSIZE_FORMAT, __func__, tid));
1954 thread_cleanup (wait->threads[i]);
1955 }
1956 }
1957 }
1958
1959 static void wait_for_tids_or_state_change (struct wait_data *wait, guint32 timeout)
1960 {
1961 guint32 i, ret, count;
1962
1963 THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
1964
1965 /* Add the thread state change event, so it wakes up if a thread changes
1966 * to background mode.
1967 */
1968 count = wait->num;
1969 if (count < MAXIMUM_WAIT_OBJECTS) {
1970 wait->handles [count] = background_change_event;
1971 count++;
1972 }
1973
1974 ret=WaitForMultipleObjectsEx (count, wait->handles, FALSE, timeout, FALSE);
1975
1976 if(ret==WAIT_FAILED) {
1977 /* See the comment in build_wait_tids() */
1978 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
1979 return;
1980 }
1981
1982 for(i=0; i<wait->num; i++)
1983 CloseHandle (wait->handles[i]);
1984
1985 if (ret == WAIT_TIMEOUT)
1986 return;
1987
1988 if (ret < wait->num) {
1989 gsize tid = wait->threads[ret]->tid;
1990 mono_threads_lock ();
1991 if (mono_g_hash_table_lookup (threads, (gpointer)tid)!=NULL) {
1992 /* See comment in wait_for_tids about thread cleanup */
1993 mono_threads_unlock ();
1994 THREAD_DEBUG (g_message ("%s: cleaning up after thread %"G_GSIZE_FORMAT, __func__, tid));
1995 thread_cleanup (wait->threads [ret]);
1996 } else
1997 mono_threads_unlock ();
1998 }
1999 }
2000
2001 static void build_wait_tids (gpointer key, gpointer value, gpointer user)
2002 {
2003 struct wait_data *wait=(struct wait_data *)user;
2004
2005 if(wait->num<MAXIMUM_WAIT_OBJECTS) {
2006 HANDLE handle;
2007 MonoThread *thread=(MonoThread *)value;
2008
2009 /* Ignore background threads, we abort them later */
2010 mono_monitor_enter (thread->synch_lock);
2011 if (thread->state & ThreadState_Background) {
2012 THREAD_DEBUG (g_message ("%s: ignoring background thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
2013 mono_monitor_exit (thread->synch_lock);
2014 return; /* just leave, ignore */
2015 }
2016 mono_monitor_exit (thread->synch_lock);
2017
2018 if (mono_gc_is_finalizer_thread (thread)) {
2019 THREAD_DEBUG (g_message ("%s: ignoring finalizer thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
2020 return;
2021 }
2022
2023 if (thread == mono_thread_current ()) {
2024 THREAD_DEBUG (g_message ("%s: ignoring current thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
2025 return;
2026 }
2027
2028 if (thread == mono_thread_get_main ()) {
2029 THREAD_DEBUG (g_message ("%s: ignoring main thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
2030 return;
2031 }
2032
2033 handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
2034 if (handle == NULL) {
2035 THREAD_DEBUG (g_message ("%s: ignoring unopenable thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
2036 return;
2037 }
2038
2039 wait->handles[wait->num]=handle;
2040 wait->threads[wait->num]=thread;
2041 wait->num++;
2042
2043 THREAD_DEBUG (g_message ("%s: adding thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
2044 } else {
2045 /* Just ignore the rest, we can't do anything with
2046 * them yet
2047 */
2048 }
2049 }
2050
2051 static gboolean
2052 remove_and_abort_threads (gpointer key, gpointer value, gpointer user)
2053 {
2054 struct wait_data *wait=(struct wait_data *)user;
2055 gsize self = GetCurrentThreadId ();
2056 MonoThread *thread = (MonoThread *) value;
2057 HANDLE handle;
2058
2059 if (wait->num >= MAXIMUM_WAIT_OBJECTS)
2060 return FALSE;
2061
2062 /* The finalizer thread is not a background thread */
2063 if (thread->tid != self && (thread->state & ThreadState_Background) != 0) {
2064
2065 handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
2066 if (handle == NULL)
2067 return FALSE;
2068
2069 if(thread->state & ThreadState_AbortRequested ||
2070 thread->state & ThreadState_Aborted) {
2071 THREAD_DEBUG (g_message ("%s: Thread id %"G_GSIZE_FORMAT" already aborting", __func__, (gsize)thread->tid));
2072 return(TRUE);
2073 }
2074
2075 /* printf ("A: %d\n", wait->num); */
2076 wait->handles[wait->num]=thread->handle;
2077 wait->threads[wait->num]=thread;
2078 wait->num++;
2079
2080 THREAD_DEBUG (g_print ("%s: Aborting id: %"G_GSIZE_FORMAT"\n", __func__, (gsize)thread->tid));
2081 mono_thread_stop (thread);
2082 return TRUE;
2083 }
2084
2085 return (thread->tid != self && !mono_gc_is_finalizer_thread (thread));
2086 }
2087
2088 void mono_thread_manage (void)
2089 {
2090 struct wait_data *wait=g_new0 (struct wait_data, 1);
2091
2092 /* join each thread that's still running */
2093 THREAD_DEBUG (g_message ("%s: Joining each running thread...", __func__));
2094
2095 mono_threads_lock ();
2096 if(threads==NULL) {
2097 THREAD_DEBUG (g_message("%s: No threads", __func__));
2098 mono_threads_unlock ();
2099 return;
2100 }
2101 mono_threads_unlock ();
2102
2103 do {
2104 mono_threads_lock ();
2105 THREAD_DEBUG (g_message ("%s: There are %d threads to join", __func__, mono_g_hash_table_size (threads));
2106 mono_g_hash_table_foreach (threads, print_tids, NULL));
2107
2108 ResetEvent (background_change_event);
2109 wait->num=0;
2110 mono_g_hash_table_foreach (threads, build_wait_tids, wait);
2111 mono_threads_unlock ();
2112 if(wait->num>0) {
2113 /* Something to wait for */
2114 wait_for_tids_or_state_change (wait, INFINITE);
2115 }
2116 THREAD_DEBUG (g_message ("%s: I have %d threads after waiting.", __func__, wait->num));
2117 } while(wait->num>0);
2118
2119 mono_runtime_set_shutting_down ();
2120
2121 THREAD_DEBUG (g_message ("%s: threadpool cleanup", __func__));
2122 mono_thread_pool_cleanup ();
2123
2124 /*
2125 * Remove everything but the finalizer thread and self.
2126 * Also abort all the background threads
2127 * */
2128 do {
2129 mono_threads_lock ();
2130
2131 wait->num = 0;
2132 mono_g_hash_table_foreach_remove (threads, remove_and_abort_threads, wait);
2133
2134 mono_threads_unlock ();
2135
2136 THREAD_DEBUG (g_message ("%s: wait->num is now %d", __func__, wait->num));
2137 if(wait->num>0) {
2138 /* Something to wait for */
2139 wait_for_tids (wait, INFINITE);
2140 }
2141 } while (wait->num > 0);
2142
2143 /*
2144 * give the subthreads a chance to really quit (this is mainly needed
2145 * to get correct user and system times from getrusage/wait/time(1)).
2146 * This could be removed if we avoid pthread_detach() and use pthread_join().
2147 */
2148 #ifndef PLATFORM_WIN32
2149 sched_yield ();
2150 #endif
2151
2152 g_free (wait);
2153 }
2154
2155 static void terminate_thread (gpointer key, gpointer value, gpointer user)
2156 {
2157 MonoThread *thread=(MonoThread *)value;
2158
2159 if(thread->tid != (gsize)user) {
2160 /*TerminateThread (thread->handle, -1);*/
2161 }
2162 }
2163
2164 void mono_thread_abort_all_other_threads (void)
2165 {
2166 gsize self = GetCurrentThreadId ();
2167
2168 mono_threads_lock ();
2169 THREAD_DEBUG (g_message ("%s: There are %d threads to abort", __func__,
2170 mono_g_hash_table_size (threads));
2171 mono_g_hash_table_foreach (threads, print_tids, NULL));
2172
2173 mono_g_hash_table_foreach (threads, terminate_thread, (gpointer)self);
2174
2175 mono_threads_unlock ();
2176 }
2177
2178 static void
2179 collect_threads (gpointer key, gpointer value, gpointer user_data)
2180 {
2181 MonoThread *thread = (MonoThread*)value;
2182 struct wait_data *wait = (struct wait_data*)user_data;
2183 HANDLE handle;
2184
2185 if (wait->num<MAXIMUM_WAIT_OBJECTS) {
2186 handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
2187 if (handle == NULL)
2188 return;
2189
2190 wait->handles [wait->num] = handle;
2191 wait->threads [wait->num] = thread;
2192 wait->num++;
2193 }
2194 }
2195
2196 /*
2197 * mono_thread_suspend_all_other_threads:
2198 *
2199 * Suspend all managed threads except the finalizer thread and this thread.
2200 */
2201 void mono_thread_suspend_all_other_threads (void)
2202 {
2203 struct wait_data *wait = g_new0 (struct wait_data, 1);
2204 int i, waitnum;
2205 gsize self = GetCurrentThreadId ();
2206 gpointer *events;
2207 guint32 eventidx = 0;
2208
2209 /*
2210 * Make a copy of the hashtable since we can't do anything with
2211 * threads while threads_mutex is held.
2212 */
2213 mono_threads_lock ();
2214 mono_g_hash_table_foreach (threads, collect_threads, wait);
2215 mono_threads_unlock ();
2216
2217 events = g_new0 (gpointer, wait->num);
2218 waitnum = 0;
2219 /* Get the suspended events that we'll be waiting for */
2220 for (i = 0; i < wait->num; ++i) {
2221 MonoThread *thread = wait->threads [i];
2222
2223 if ((thread->tid == self) || mono_gc_is_finalizer_thread (thread)) {
2224 //CloseHandle (wait->handles [i]);
2225 wait->threads [i] = NULL; /* ignore this thread in next loop */
2226 continue;
2227 }
2228
2229 mono_monitor_enter (thread->synch_lock);
2230
2231 if ((thread->state & ThreadState_Suspended) != 0 ||
2232 (thread->state & ThreadState_SuspendRequested) != 0 ||
2233 (thread->state & ThreadState_StopRequested) != 0 ||
2234 (thread->state & ThreadState_Stopped) != 0) {
2235 mono_monitor_exit (thread->synch_lock);
2236 CloseHandle (wait->handles [i]);
2237 wait->threads [i] = NULL; /* ignore this thread in next loop */
2238 continue;
2239 }
2240
2241 /* Convert abort requests into suspend requests */
2242 if ((thread->state & ThreadState_AbortRequested) != 0)
2243 thread->state &= ~ThreadState_AbortRequested;
2244
2245 thread->state |= ThreadState_SuspendRequested;
2246
2247 if (thread->suspended_event == NULL) {
2248 thread->suspended_event = CreateEvent (NULL, TRUE, FALSE, NULL);
2249 if (thread->suspended_event == NULL) {
2250 /* Forget this one and go on to the next */
2251 mono_monitor_exit (thread->synch_lock);
2252 continue;
2253 }
2254 }
2255
2256 events [eventidx++] = thread->suspended_event;
2257 mono_monitor_exit (thread->synch_lock);
2258
2259 /* Signal the thread to suspend */
2260 signal_thread_state_change (thread);
2261 }
2262
2263 WaitForMultipleObjectsEx (eventidx, events, TRUE, INFINITE, FALSE);
2264 for (i = 0; i < wait->num; ++i) {
2265 MonoThread *thread = wait->threads [i];
2266
2267 if (thread == NULL)
2268 continue;
2269
2270 mono_monitor_enter (thread->synch_lock);
2271 CloseHandle (thread->suspended_event);
2272 thread->suspended_event = NULL;
2273 mono_monitor_exit (thread->synch_lock);
2274 }
2275
2276 g_free (events);
2277 g_free (wait);
2278 }
2279
2280 /**
2281 * mono_threads_request_thread_dump:
2282 *
2283 * Ask all threads except the current to print their stacktrace to stdout.
2284 */
2285 void
2286 mono_threads_request_thread_dump (void)
2287 {
2288 struct wait_data *wait = g_new0 (struct wait_data, 1);
2289 int i;
2290
2291 /*
2292 * Make a copy of the hashtable since we can't do anything with
2293 * threads while threads_mutex is held.
2294 */
2295 mono_threads_lock ();
2296 mono_g_hash_table_foreach (threads, collect_threads, wait);
2297 mono_threads_unlock ();
2298
2299 for (i = 0; i < wait->num; ++i) {
2300 MonoThread *thread = wait->threads [i];
2301
2302 if (!mono_gc_is_finalizer_thread (thread) && (thread != mono_thread_current ()) && !thread->thread_dump_requested) {
2303 thread->thread_dump_requested = TRUE;
2304
2305 signal_thread_state_change (thread);
2306 }
2307
2308 CloseHandle (wait->handles [i]);
2309 }
2310 }
2311
2312 /*
2313 * mono_thread_push_appdomain_ref:
2314 *
2315 * Register that the current thread may have references to objects in domain
2316 * @domain on its stack. Each call to this function should be paired with a
2317 * call to pop_appdomain_ref.
2318 */
2319 void
2320 mono_thread_push_appdomain_ref (MonoDomain *domain)
2321 {
2322 MonoThread *thread = mono_thread_current ();
2323
2324 if (thread) {
2325 /* printf ("PUSH REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, domain->friendly_name); */
2326 mono_threads_lock ();
2327 thread->appdomain_refs = g_slist_prepend (thread->appdomain_refs, domain);
2328 mono_threads_unlock ();
2329 }
2330 }
2331
2332 void
2333 mono_thread_pop_appdomain_ref (void)
2334 {
2335 MonoThread *thread = mono_thread_current ();
2336
2337 if (thread) {
2338 /* printf ("POP REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, ((MonoDomain*)(thread->appdomain_refs->data))->friendly_name); */
2339 mono_threads_lock ();
2340 /* FIXME: How can the list be empty ? */
2341 if (thread->appdomain_refs)
2342 thread->appdomain_refs = g_slist_remove (thread->appdomain_refs, thread->appdomain_refs->data);
2343 mono_threads_unlock ();
2344 }
2345 }
2346
2347 gboolean
2348 mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain)
2349 {
2350 gboolean res;
2351 mono_threads_lock ();
2352 res = g_slist_find (thread->appdomain_refs, domain) != NULL;
2353 mono_threads_unlock ();
2354 return res;
2355 }
2356
2357 typedef struct abort_appdomain_data {
2358 struct wait_data wait;
2359 MonoDomain *domain;
2360 } abort_appdomain_data;
2361
2362 static void
2363 abort_appdomain_thread (gpointer key, gpointer value, gpointer user_data)
2364 {
2365 MonoThread *thread = (MonoThread*)value;
2366 abort_appdomain_data *data = (abort_appdomain_data*)user_data;
2367 MonoDomain *domain = data->domain;
2368
2369 if (mono_thread_has_appdomain_ref (thread, domain)) {
2370 HANDLE handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
2371 if (handle == NULL)
2372 return;
2373
2374 /* printf ("ABORTING THREAD %p BECAUSE IT REFERENCES DOMAIN %s.\n", thread->tid, domain->friendly_name); */
2375
2376 ves_icall_System_Threading_Thread_Abort (thread, NULL);
2377
2378 if(data->wait.num<MAXIMUM_WAIT_OBJECTS) {
2379 data->wait.handles [data->wait.num] = handle;
2380 data->wait.threads [data->wait.num] = thread;
2381 data->wait.num++;
2382 } else {
2383 /* Just ignore the rest, we can't do anything with
2384 * them yet
2385 */
2386 }
2387 }
2388 }
2389
2390 /*
2391 * mono_threads_abort_appdomain_threads:
2392 *
2393 * Abort threads which has references to the given appdomain.
2394 */
2395 gboolean
2396 mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout)
2397 {
2398 abort_appdomain_data user_data;
2399 guint32 start_time;
2400
2401 /* printf ("ABORT BEGIN.\n"); */
2402
2403 start_time = GetTickCount ();
2404 do {
2405 mono_threads_lock ();
2406
2407 user_data.domain = domain;
2408 user_data.wait.num = 0;
2409 mono_g_hash_table_foreach (threads, abort_appdomain_thread, &user_data);
2410 mono_threads_unlock ();
2411
2412 if (user_data.wait.num > 0)
2413 /*
2414 * We should wait for the threads either to abort, or to leave the
2415 * domain. We can't do the latter, so we wait with a timeout.
2416 */
2417 wait_for_tids (&user_data.wait, 100);
2418
2419 /* Update remaining time */
2420 timeout -= GetTickCount () - start_time;
2421 start_time = GetTickCount ();
2422
2423 if (timeout < 0)
2424 return FALSE;
2425 }
2426 while (user_data.wait.num > 0);
2427
2428 /* printf ("ABORT DONE.\n"); */
2429
2430 return TRUE;
2431 }
2432
2433 static void
2434 clear_cached_culture (gpointer key, gpointer value, gpointer user_data)
2435 {
2436 MonoThread *thread = (MonoThread*)value;
2437 MonoDomain *domain = (MonoDomain*)user_data;
2438 int i;
2439
2440 /* No locking needed here */
2441 /* FIXME: why no locking? writes to the cache are protected with synch_lock above */
2442
2443 if (thread->cached_culture_info) {
2444 for (i = 0; i < NUM_CACHED_CULTURES * 2; ++i) {
2445 MonoObject *obj = mono_array_get (thread->cached_culture_info, MonoObject*, i);
2446 if (obj && obj->vtable->domain == domain)
2447 mono_array_set (thread->cached_culture_info, MonoObject*, i, NULL);
2448 }
2449 }
2450 }
2451
2452 /*
2453 * mono_threads_clear_cached_culture:
2454 *
2455 * Clear the cached_current_culture from all threads if it is in the
2456 * given appdomain.
2457 */
2458 void
2459 mono_threads_clear_cached_culture (MonoDomain *domain)
2460 {
2461 mono_threads_lock ();
2462 mono_g_hash_table_foreach (threads, clear_cached_culture, domain);
2463 mono_threads_unlock ();
2464 }
2465
2466 /*
2467 * mono_thread_get_pending_exception:
2468 *
2469 * Return an exception which needs to be raised when leaving a catch clause.
2470 * This is used for undeniable exception propagation.
2471 */
2472 MonoException*
2473 mono_thread_get_pending_exception (void)
2474 {
2475 MonoThread *thread = mono_thread_current ();
2476
2477 MONO_ARCH_SAVE_REGS;
2478
2479 if (thread && thread->abort_exc && !is_running_protected_wrapper ()) {
2480 /*
2481 * FIXME: Clear the abort exception and return an AppDomainUnloaded
2482 * exception if the thread no longer references a dying appdomain.
2483 */
2484 thread->abort_exc->trace_ips = NULL;
2485 thread->abort_exc->stack_trace = NULL;
2486 return thread->abort_exc;
2487 }
2488
2489 return NULL;
2490 }
2491
2492 #define NUM_STATIC_DATA_IDX 8
2493 static const int static_data_size [NUM_STATIC_DATA_IDX] = {
2494 1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216
2495 };
2496
2497
2498 /*
2499 * mono_alloc_static_data
2500 *
2501 * Allocate memory blocks for storing threads or context static data
2502 */
2503 static void
2504 mono_alloc_static_data (gpointer **static_data_ptr, guint32 offset)
2505 {
2506 guint idx = (offset >> 24) - 1;
2507 int i;
2508
2509 gpointer* static_data = *static_data_ptr;
2510 if (!static_data) {
2511 static_data = mono_gc_alloc_fixed (static_data_size [0], NULL);
2512 *static_data_ptr = static_data;
2513 static_data [0] = static_data;
2514 }
2515
2516 for (i = 1; i <= idx; ++i) {
2517 if (static_data [i])
2518 continue;
2519 static_data [i] = mono_gc_alloc_fixed (static_data_size [i], NULL);
2520 }
2521 }
2522
2523 /*
2524 * mono_init_static_data_info
2525 *
2526 * Initializes static data counters
2527 */
2528 static void mono_init_static_data_info (StaticDataInfo *static_data)
2529 {
2530 static_data->idx = 0;
2531 static_data->offset = 0;
2532 }
2533
2534 /*
2535 * mono_alloc_static_data_slot
2536 *
2537 * Generates an offset for static data. static_data contains the counters
2538 * used to generate it.
2539 */
2540 static guint32
2541 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align)
2542 {
2543 guint32 offset;
2544
2545 if (!static_data->idx && !static_data->offset) {
2546 /*
2547 * we use the first chunk of the first allocation also as
2548 * an array for the rest of the data
2549 */
2550 static_data->offset = sizeof (gpointer) * NUM_STATIC_DATA_IDX;
2551 }
2552 static_data->offset += align - 1;
2553 static_data->offset &= ~(align - 1);
2554 if (static_data->offset + size >= static_data_size [static_data->idx]) {
2555 static_data->idx ++;
2556 g_assert (size <= static_data_size [static_data->idx]);
2557 /*
2558 * massive unloading and reloading of domains with thread-static
2559 * data may eventually exceed the allocated storage...
2560 * Need to check what the MS runtime does in that case.
2561 * Note that for each appdomain, we need to allocate a separate
2562 * thread data slot for security reasons. We could keep track
2563 * of the slots per-domain and when the domain is unloaded
2564 * out the slots on a sort of free list.
2565 */
2566 g_assert (static_data->idx < NUM_STATIC_DATA_IDX);
2567 static_data->offset = 0;
2568 }
2569 offset = static_data->offset | ((static_data->idx + 1) << 24);
2570 static_data->offset += size;
2571 return offset;
2572 }
2573
2574 /*
2575 * ensure thread static fields already allocated are valid for thread
2576 * This function is called when a thread is created or on thread attach.
2577 */
2578 static void
2579 thread_adjust_static_data (MonoThread *thread)
2580 {
2581 guint32 offset;
2582
2583 mono_threads_lock ();
2584 if (thread_static_info.offset || thread_static_info.idx > 0) {
2585 /* get the current allocated size */
2586 offset = thread_static_info.offset | ((thread_static_info.idx + 1) << 24);
2587 mono_alloc_static_data (&(thread->static_data), offset);
2588 }
2589 mono_threads_unlock ();
2590 }
2591
2592 static void
2593 alloc_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
2594 {
2595 MonoThread *thread = value;
2596 guint32 offset = GPOINTER_TO_UINT (user);
2597
2598 mono_alloc_static_data (&(thread->static_data), offset);
2599 }
2600
2601 /*
2602 * The offset for a special static variable is composed of three parts:
2603 * a bit that indicates the type of static data (0:thread, 1:context),
2604 * an index in the array of chunks of memory for the thread (thread->static_data)
2605 * and an offset in that chunk of mem. This allows allocating less memory in the
2606 * common case.
2607 */
2608
2609 guint32
2610 mono_alloc_special_static_data (guint32 static_type, guint32 size, guint32 align)
2611 {
2612 guint32 offset;
2613 if (static_type == SPECIAL_STATIC_THREAD)
2614 {
2615 mono_threads_lock ();
2616 offset = mono_alloc_static_data_slot (&thread_static_info, size, align);
2617 /* This can be called during startup */
2618 if (threads != NULL)
2619 mono_g_hash_table_foreach (threads, alloc_thread_static_data_helper, GUINT_TO_POINTER (offset));
2620 mono_threads_unlock ();
2621 }
2622 else
2623 {
2624 g_assert (static_type == SPECIAL_STATIC_CONTEXT);
2625 mono_contexts_lock ();
2626 offset = mono_alloc_static_data_slot (&context_static_info, size, align);
2627 mono_contexts_unlock ();
2628 offset |= 0x80000000; /* Set the high bit to indicate context static data */
2629 }
2630 return offset;
2631 }
2632
2633 gpointer
2634 mono_get_special_static_data (guint32 offset)
2635 {
2636 /* The high bit means either thread (0) or static (1) data. */
2637
2638 guint32 static_type = (offset & 0x80000000);
2639 int idx;
2640
2641 offset &= 0x7fffffff;
2642 idx = (offset >> 24) - 1;
2643
2644 if (static_type == 0)
2645 {
2646 MonoThread *thread = mono_thread_current ();
2647 return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
2648 }
2649 else
2650 {
2651 /* Allocate static data block under demand, since we don't have a list
2652 // of contexts
2653 */
2654 MonoAppContext *context = mono_context_get ();
2655 if (!context->static_data || !context->static_data [idx]) {
2656 mono_contexts_lock ();
2657 mono_alloc_static_data (&(context->static_data), offset);
2658 mono_contexts_unlock ();
2659 }
2660 return ((char*) context->static_data [idx]) + (offset & 0xffffff);
2661 }
2662 }
2663
2664 static MonoClassField *local_slots = NULL;
2665
2666 typedef struct {
2667 /* local tls data to get locals_slot from a thread */
2668 guint32 offset;
2669 int idx;
2670 /* index in the locals_slot array */
2671 int slot;
2672 } LocalSlotID;
2673
2674 static void
2675 clear_local_slot (gpointer key, gpointer value, gpointer user_data)
2676 {
2677 LocalSlotID *sid = user_data;
2678 MonoThread *thread = (MonoThread*)value;
2679 MonoArray *slots_array;
2680 /*
2681 * the static field is stored at: ((char*) thread->static_data [idx]) + (offset & 0xffffff);
2682 * it is for the right domain, so we need to check if it is allocated an initialized
2683 * for the current thread.
2684 */
2685 /*g_print ("handling thread %p\n", thread);*/
2686 if (!thread->static_data || !thread->static_data [sid->idx])
2687 return;
2688 slots_array = *(MonoArray **)(((char*) thread->static_data [sid->idx]) + (sid->offset & 0xffffff));
2689 if (!slots_array || sid->slot >= mono_array_length (slots_array))
2690 return;
2691 mono_array_set (slots_array, MonoObject*, sid->slot, NULL);
2692 }
2693
2694 void
2695 mono_thread_free_local_slot_values (int slot, MonoBoolean thread_local)
2696 {
2697 MonoDomain *domain;
2698 LocalSlotID sid;
2699 sid.slot = slot;
2700 if (thread_local) {
2701 void *addr = NULL;
2702 if (!local_slots) {
2703 local_slots = mono_class_get_field_from_name (mono_defaults.thread_class, "local_slots");
2704 if (!local_slots) {
2705 g_warning ("local_slots field not found in Thread class");
2706 return;
2707 }
2708 }
2709 domain = mono_domain_get ();
2710 mono_domain_lock (domain);
2711 if (domain->special_static_fields)
2712 addr = g_hash_table_lookup (domain->special_static_fields, local_slots);
2713 mono_domain_unlock (domain);
2714 if (!addr)
2715 return;
2716 /*g_print ("freeing slot %d at %p\n", slot, addr);*/
2717 sid.offset = GPOINTER_TO_UINT (addr);
2718 sid.offset &= 0x7fffffff;
2719 sid.idx = (sid.offset >> 24) - 1;
2720 mono_threads_lock ();
2721 mono_g_hash_table_foreach (threads, clear_local_slot, &sid);
2722 mono_threads_unlock ();
2723 } else {
2724 /* FIXME: clear the slot for MonoAppContexts, too */
2725 }
2726 }
2727
2728 #ifdef __MINGW32__
2729 static CALLBACK void dummy_apc (ULONG_PTR param)
2730 {
2731 }
2732 #else
2733 static guint32 dummy_apc (gpointer param)
2734 {
2735 return 0;
2736 }
2737 #endif
2738
2739 /*
2740 * mono_thread_execute_interruption
2741 *
2742 * Performs the operation that the requested thread state requires (abort,
2743 * suspend or stop)
2744 */
2745 static MonoException* mono_thread_execute_interruption (MonoThread *thread)
2746 {
2747 mono_monitor_enter (thread->synch_lock);
2748
2749 if (thread->interruption_requested) {
2750 /* this will consume pending APC calls */
2751 WaitForSingleObjectEx (GetCurrentThread(), 0, TRUE);
2752 InterlockedDecrement (&thread_interruption_requested);
2753 thread->interruption_requested = FALSE;
2754 }
2755
2756 if ((thread->state & ThreadState_AbortRequested) != 0) {
2757 if (thread->abort_exc == NULL)
2758 MONO_OBJECT_SETREF (thread, abort_exc, mono_get_exception_thread_abort ());
2759 mono_monitor_exit (thread->synch_lock);
2760 return thread->abort_exc;
2761 }
2762 else if ((thread->state & ThreadState_SuspendRequested) != 0) {
2763 thread->state &= ~ThreadState_SuspendRequested;
2764 thread->state |= ThreadState_Suspended;
2765 thread->suspend_event = CreateEvent (NULL, TRUE, FALSE, NULL);
2766 if (thread->suspend_event == NULL) {
2767 mono_monitor_exit (thread->synch_lock);
2768 return(NULL);
2769 }
2770 if (thread->suspended_event)
2771 SetEvent (thread->suspended_event);
2772 mono_monitor_exit (thread->synch_lock);
2773
2774 WaitForSingleObject (thread->suspend_event, INFINITE);
2775
2776 mono_monitor_enter (thread->synch_lock);
2777 CloseHandle (thread->suspend_event);
2778 thread->suspend_event = NULL;
2779 thread->state &= ~ThreadState_Suspended;
2780
2781 /* The thread that requested the resume will have replaced this event
2782 * and will be waiting for it
2783 */
2784 SetEvent (thread->resume_event);
2785 mono_monitor_exit (thread->synch_lock);
2786 return NULL;
2787 }
2788 else if ((thread->state & ThreadState_StopRequested) != 0) {
2789 /* FIXME: do this through the JIT? */
2790 mono_monitor_exit (thread->synch_lock);
2791 mono_thread_exit ();
2792 return NULL;
2793 } else if (thread->thread_interrupt_requested) {
2794 mono_monitor_exit (thread->synch_lock);
2795 return(mono_get_exception_thread_interrupted ());
2796 }
2797
2798 mono_monitor_exit (thread->synch_lock);
2799 return NULL;
2800 }
2801
2802 /*
2803 * mono_thread_request_interruption
2804 *
2805 * A signal handler can call this method to request the interruption of a
2806 * thread. The result of the interruption will depend on the current state of
2807 * the thread. If the result is an exception that needs to be throw, it is
2808 * provided as return value.
2809 */
2810 MonoException* mono_thread_request_interruption (gboolean running_managed)
2811 {
2812 MonoThread *thread = mono_thread_current ();
2813
2814 /* The thread may already be stopping */
2815 if (thread == NULL)
2816 return NULL;
2817
2818 mono_monitor_enter (thread->synch_lock);
2819
2820 if (thread->interruption_requested) {
2821 mono_monitor_exit (thread->synch_lock);
2822 return NULL;
2823 }
2824
2825 if (!running_managed || is_running_protected_wrapper ()) {
2826 /* Can't stop while in unmanaged code. Increase the global interruption
2827 request count. When exiting the unmanaged method the count will be
2828 checked and the thread will be interrupted. */
2829
2830 InterlockedIncrement (&thread_interruption_requested);
2831 thread->interruption_requested = TRUE;
2832 mono_monitor_exit (thread->synch_lock);
2833
2834 /* this will awake the thread if it is in WaitForSingleObject
2835 or similar */
2836 QueueUserAPC ((PAPCFUNC)dummy_apc, thread->handle, NULL);
2837 return NULL;
2838 }
2839 else {
2840 mono_monitor_exit (thread->synch_lock);
2841 return mono_thread_execute_interruption (thread);
2842 }
2843 }
2844
2845 gboolean mono_thread_interruption_requested ()
2846 {
2847 if (thread_interruption_requested) {
2848 MonoThread *thread = mono_thread_current ();
2849 /* The thread may already be stopping */
2850 if (thread != NULL)
2851 return (thread->interruption_requested);
2852 }
2853 return FALSE;
2854 }
2855
2856 static void mono_thread_interruption_checkpoint_request (gboolean bypass_abort_protection)
2857 {
2858 MonoThread *thread = mono_thread_current ();
2859
2860 /* The thread may already be stopping */
2861 if (thread == NULL)
2862 return;
2863
2864 if (thread->interruption_requested && (bypass_abort_protection || !is_running_protected_wrapper ())) {
2865 MonoException* exc = mono_thread_execute_interruption (thread);
2866 if (exc) mono_raise_exception (exc);
2867 }
2868 }
2869
2870 /*
2871 * Performs the interruption of the current thread, if one has been requested,
2872 * and the thread is not running a protected wrapper.
2873 */
2874 void mono_thread_interruption_checkpoint ()
2875 {
2876 mono_thread_interruption_checkpoint_request (FALSE);
2877 }
2878
2879 /*
2880 * Performs the interruption of the current thread, if one has been requested.
2881 */
2882 void mono_thread_force_interruption_checkpoint ()
2883 {
2884 mono_thread_interruption_checkpoint_request (TRUE);
2885 }
2886
2887 /**
2888 * mono_thread_interruption_request_flag:
2889 *
2890 * Returns the address of a flag that will be non-zero if an interruption has
2891 * been requested for a thread. The thread to interrupt may not be the current
2892 * thread, so an additional call to mono_thread_interruption_requested() or
2893 * mono_thread_interruption_checkpoint() is allways needed if the flag is not
2894 * zero.
2895 */
2896 gint32* mono_thread_interruption_request_flag ()
2897 {
2898 return &thread_interruption_requested;
2899 }
Mirror of the official Mono project git repository