mono/mini/tasklets.c

   1 /**
   2  * \file
   3  */
   4
   5 #include "config.h"
   6 #include "tasklets.h"
   7 #include "mono/metadata/exception.h"
   8 #include "mono/metadata/gc-internals.h"
   9 #include "mono/metadata/icall-internals.h"
  10 #include "mini.h"
  11 #include "mini-runtime.h"
  12 #include "mono/metadata/loader-internals.h"
  13
  14 #if defined(MONO_SUPPORT_TASKLETS)
  15
  16 #include "mono/metadata/loader-internals.h"
  17
  18 static mono_mutex_t tasklets_mutex;
  19 #define tasklets_lock() mono_os_mutex_lock(&tasklets_mutex)
  20 #define tasklets_unlock() mono_os_mutex_unlock(&tasklets_mutex)
  21
  22 /* LOCKING: tasklets_mutex is assumed to e taken */
  23 static void
  24 internal_init (void)
  25 {
  26         if (!mono_gc_is_moving ())
  27                 /* Boehm requires the keepalive stacks to be kept in a hash since mono_gc_alloc_fixed () returns GC memory */
  28                 g_assert_not_reached ();
  29 }
  30
  31 static void*
  32 continuation_alloc (void)
  33 {
  34         MonoContinuation *cont = g_new0 (MonoContinuation, 1);
  35         return cont;
  36 }
  37
  38 static void
  39 continuation_free (MonoContinuation *cont)
  40 {
  41         if (cont->saved_stack)
  42                 mono_gc_free_fixed (cont->saved_stack);
  43         g_free (cont);
  44 }
  45
  46 static MonoException*
  47 continuation_mark_frame (MonoContinuation *cont)
  48 {
  49         MonoJitTlsData *jit_tls;
  50         MonoLMF *lmf;
  51         MonoContext ctx, new_ctx;
  52         MonoJitInfo *ji, rji;
  53         int endloop = FALSE;
  54
  55         if (cont->domain)
  56                 return mono_get_exception_argument ("cont", "Already marked");
  57
  58         jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls ();
  59         lmf = mono_get_lmf();
  60         cont->domain = mono_domain_get ();
  61         cont->thread_id = mono_native_thread_id_get ();
  62
  63         /* get to the frame that called Mark () */
  64         memset (&rji, 0, sizeof (rji));
  65         memset (&ctx, 0, sizeof (ctx));
  66         do {
  67                 ji = mono_find_jit_info (cont->domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, NULL);
  68                 if (!ji || ji == (gpointer)-1) {
  69                         return mono_get_exception_not_supported ("Invalid stack frame");
  70                 }
  71                 ctx = new_ctx;
  72                 if (endloop)
  73                         break;
  74                 if (!ji->is_trampoline && strcmp (jinfo_get_method (ji)->name, "Mark") == 0)
  75                         endloop = TRUE;
  76         } while (1);
  77
  78         cont->top_sp = MONO_CONTEXT_GET_SP (&ctx);
  79         /*g_print ("method: %s, sp: %p\n", jinfo_get_method (ji)->name, cont->top_sp);*/
  80
  81         return NULL;
  82 }
  83
  84 static int
  85 continuation_store (MonoContinuation *cont, int state, MonoException **e)
  86 {
  87         MonoLMF *lmf = mono_get_lmf ();
  88         gsize num_bytes;
  89
  90         if (!cont->domain) {
  91                 *e =  mono_get_exception_argument ("cont", "Continuation not initialized");
  92                 return 0;
  93         }
  94         if (cont->domain != mono_domain_get () || !mono_native_thread_id_equals (cont->thread_id, mono_native_thread_id_get ())) {
  95                 *e = mono_get_exception_argument ("cont", "Continuation from another thread or domain");
  96                 return 0;
  97         }
  98
  99         cont->lmf = lmf;
 100         cont->return_ip = __builtin_extract_return_addr (__builtin_return_address (0));
 101         cont->return_sp = __builtin_frame_address (0);
 102
 103         num_bytes = (char*)cont->top_sp - (char*)cont->return_sp;
 104
 105         /*g_print ("store: %d bytes, sp: %p, ip: %p, lmf: %p\n", num_bytes, cont->return_sp, cont->return_ip, lmf);*/
 106
 107         if (cont->saved_stack && num_bytes <= cont->stack_alloc_size) {
 108                 /* clear to avoid GC retention */
 109                 if (num_bytes < cont->stack_used_size) {
 110                         memset ((char*)cont->saved_stack + num_bytes, 0, cont->stack_used_size - num_bytes);
 111                 }
 112                 cont->stack_used_size = num_bytes;
 113         } else {
 114                 tasklets_lock ();
 115                 internal_init ();
 116                 if (cont->saved_stack)
 117                         mono_gc_free_fixed (cont->saved_stack);
 118                 cont->stack_used_size = num_bytes;
 119                 cont->stack_alloc_size = num_bytes * 1.1;
 120                 cont->saved_stack = mono_gc_alloc_fixed_no_descriptor (cont->stack_alloc_size, MONO_ROOT_SOURCE_THREADING, NULL, "Tasklet Saved Stack");
 121                 tasklets_unlock ();
 122         }
 123         memcpy (cont->saved_stack, cont->return_sp, num_bytes);
 124
 125         return state;
 126 }
 127
 128 static MonoException*
 129 continuation_restore (MonoContinuation *cont, int state)
 130 {
 131         MonoLMF **lmf_addr = mono_get_lmf_addr ();
 132         MonoContinuationRestore restore_state = mono_tasklets_arch_restore ();
 133
 134         if (!cont->domain || !cont->return_sp)
 135                 return mono_get_exception_argument ("cont", "Continuation not initialized");
 136         if (cont->domain != mono_domain_get () || !mono_native_thread_id_equals (cont->thread_id, mono_native_thread_id_get ()))
 137                 return mono_get_exception_argument ("cont", "Continuation from another thread or domain");
 138
 139         /*g_print ("restore: %p, state: %d\n", cont, state);*/
 140         *lmf_addr = cont->lmf;
 141         restore_state (cont, state, lmf_addr);
 142         g_assert_not_reached ();
 143 }
 144
 145 void
 146 mono_tasklets_init (void)
 147 {
 148         mono_os_mutex_init_recursive (&tasklets_mutex);
 149
 150         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::alloc", continuation_alloc);
 151         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::free", continuation_free);
 152         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::mark", continuation_mark_frame);
 153         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::store", continuation_store);
 154         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::restore", continuation_restore);
 155 }
 156
 157 void
 158 mono_tasklets_cleanup (void)
 159 {
 160 }
 161 #else
 162
 163 static
 164 void continuations_not_supported (void)
 165 {
 166         ERROR_DECL (error);
 167         mono_error_set_not_implemented (error, "Tasklets are not implemented on this platform.");
 168         mono_error_set_pending_exception (error);
 169 }
 170
 171 static void*
 172 continuation_alloc (void)
 173 {
 174         continuations_not_supported ();
 175         return NULL;
 176 }
 177
 178 static void
 179 continuation_free (MonoContinuation *cont)
 180 {
 181         continuations_not_supported ();
 182 }
 183
 184 static MonoException*
 185 continuation_mark_frame (MonoContinuation *cont)
 186 {
 187         continuations_not_supported ();
 188         return NULL;
 189 }
 190
 191 static int
 192 continuation_store (MonoContinuation *cont, int state, MonoException **e)
 193 {
 194         continuations_not_supported ();
 195         return 0;
 196 }
 197
 198 static MonoException*
 199 continuation_restore (MonoContinuation *cont, int state)
 200 {
 201         continuations_not_supported ();
 202         return NULL;
 203 }
 204
 205 void
 206 mono_tasklets_init(void)
 207 {
 208         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::alloc", continuation_alloc);
 209         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::free", continuation_free);
 210         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::mark", continuation_mark_frame);
 211         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::store", continuation_store);
 212         mono_add_internal_call_internal ("Mono.Tasklets.Continuation::restore", continuation_restore);
 213
 214 }
 215 #endif
 216