From 70102de4c05c63ffe8ded6c3f9744b0219021bc9 Mon Sep 17 00:00:00 2001 From: Jay Krell Date: Thu, 29 Aug 2019 20:51:15 -0700 Subject: [PATCH] [coop] Convert System_Runtime_Remoting_Messaging_AsyncResult, etc. (mono/mono#16566) * [coop] Convert System_Runtime_Remoting_Messaging_AsyncResult_Invoke, etc. * Remove mono_load_remote_field_checked from this PR. * Pin ac->msg earlier (should not matter). * Add missing barrier. * Pin slightly earlier -- still should not matter. Commit migrated from https://github.com/mono/mono/commit/3db78e829c0909bf9ca459e3a3e1033365386569 --- src/mono/mono/metadata/icall-def.h | 2 +- src/mono/mono/metadata/icall-table.h | 1 + src/mono/mono/metadata/object-internals.h | 8 ---- src/mono/mono/metadata/object.c | 75 ++++++++++++++++++++++--------- 4 files changed, 56 insertions(+), 30 deletions(-) diff --git a/src/mono/mono/metadata/icall-def.h b/src/mono/mono/metadata/icall-def.h index 23be6ed..5d97eb1 100644 --- a/src/mono/mono/metadata/icall-def.h +++ b/src/mono/mono/metadata/icall-def.h @@ -837,7 +837,7 @@ HANDLES(CONTEXT_1, "RegisterContext", ves_icall_System_Runtime_Remoting_Contexts HANDLES(CONTEXT_2, "ReleaseContext", ves_icall_System_Runtime_Remoting_Contexts_Context_ReleaseContext, void, 1, (MonoAppContext)) ICALL_TYPE(ARES, "System.Runtime.Remoting.Messaging.AsyncResult", ARES_1) -ICALL(ARES_1, "Invoke", ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke) +HANDLES(ARES_1, "Invoke", ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke, MonoObject, 1, (MonoAsyncResult)) #ifndef DISABLE_REMOTING ICALL_TYPE(REALP, "System.Runtime.Remoting.Proxies.RealProxy", REALP_1) diff --git a/src/mono/mono/metadata/icall-table.h b/src/mono/mono/metadata/icall-table.h index e9d2283..e27caf1 100644 --- a/src/mono/mono/metadata/icall-table.h +++ b/src/mono/mono/metadata/icall-table.h @@ -189,6 +189,7 @@ typedef MonoReflectionModuleHandle MonoReflectionModuleOutHandle; #define MONO_HANDLE_TYPE_WRAP_MonoAppDomain ICALL_HANDLES_WRAP_OBJ #define MONO_HANDLE_TYPE_WRAP_MonoAppDomainSetup ICALL_HANDLES_WRAP_OBJ #define MONO_HANDLE_TYPE_WRAP_MonoArray ICALL_HANDLES_WRAP_OBJ +#define MONO_HANDLE_TYPE_WRAP_MonoAsyncResult ICALL_HANDLES_WRAP_OBJ #define MONO_HANDLE_TYPE_WRAP_MonoCalendarData ICALL_HANDLES_WRAP_OBJ #define MONO_HANDLE_TYPE_WRAP_MonoComInteropProxy ICALL_HANDLES_WRAP_OBJ #define MONO_HANDLE_TYPE_WRAP_MonoComObject ICALL_HANDLES_WRAP_OBJ diff --git a/src/mono/mono/metadata/object-internals.h b/src/mono/mono/metadata/object-internals.h index e49bc07..2490b30 100644 --- a/src/mono/mono/metadata/object-internals.h +++ b/src/mono/mono/metadata/object-internals.h @@ -863,10 +863,6 @@ MONO_COLD void mono_set_pending_exception (MonoException *exc); MonoAsyncResult * mono_async_result_new (MonoDomain *domain, gpointer handle, MonoObject *state, gpointer data, MonoObject *object_data, MonoError *error); -ICALL_EXPORT -MonoObject * -ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares); - MonoWaitHandle * mono_wait_handle_new (MonoDomain *domain, gpointer handle, MonoError *error); @@ -877,10 +873,6 @@ gboolean mono_message_init (MonoDomain *domain, MonoMethodMessage *this_obj, MonoReflectionMethod *method, MonoArray *out_args, MonoError *error); -MonoObject * -mono_message_invoke (MonoObject *target, MonoMethodMessage *msg, - MonoObject **exc, MonoArray **out_args, MonoError *error); - MonoMethodMessage * mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke, MonoDelegate **cb, MonoObject **state, MonoError *error); diff --git a/src/mono/mono/metadata/object.c b/src/mono/mono/metadata/object.c index 1b84277..f9245bf 100644 --- a/src/mono/mono/metadata/object.c +++ b/src/mono/mono/metadata/object.c @@ -201,14 +201,14 @@ typedef struct /* for locking access to type_initialization_hash and blocked_thread_hash */ static MonoCoopMutex type_initialization_section; -static inline void +static void mono_type_initialization_lock (void) { /* The critical sections protected by this lock in mono_runtime_class_init_full () can block */ mono_coop_mutex_lock (&type_initialization_section); } -static inline void +static void mono_type_initialization_unlock (void) { mono_coop_mutex_unlock (&type_initialization_section); @@ -8252,61 +8252,80 @@ mono_async_result_new (MonoDomain *domain, HANDLE handle, MonoObject *state, gpo return res; } -MonoObject * -ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares) +static MonoObject* +mono_message_invoke (MonoThreadInfo* mono_thread_info_current_var, + MonoObject* target, MonoMethodMessage* msg, + MonoObject** exc, MonoArray** out_args, MonoError* error); +MonoObjectHandle +ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResultHandle aresh, MonoError* error) { MONO_REQ_GC_UNSAFE_MODE; - ERROR_DECL (error); + SETUP_ICALL_FUNCTION; + MonoAsyncCall *ac; - MonoObject *res; + MonoObjectHandle res = MONO_HANDLE_NEW (MonoObject, NULL); + MonoAsyncResult* ares = MONO_HANDLE_RAW (aresh); g_assert (ares); g_assert (ares->async_delegate); + MONO_HANDLE_NEW (MonoObject, ares->async_delegate); ac = (MonoAsyncCall*) ares->object_data; + MONO_HANDLE_NEW (MonoAsyncCall, ac); + if (!ac) { - res = mono_runtime_delegate_invoke_checked (ares->async_delegate, (void**) &ares->async_state, error); - if (mono_error_set_pending_exception (error)) - return NULL; + MONO_HANDLE_ASSIGN_RAW (res, mono_runtime_delegate_invoke_checked (ares->async_delegate, (void**) &ares->async_state, error)); + return_val_if_nok (error, NULL_HANDLE); } else { gpointer wait_event = NULL; + MONO_HANDLE_NEW (MonoMethodMessage, ac->msg); + ac->msg->exc = NULL; - res = mono_message_invoke (ares->async_delegate, ac->msg, &ac->msg->exc, &ac->out_args, error); + MONO_HANDLE_ASSIGN_RAW (res, mono_message_invoke (mono_thread_info_current_var, + ares->async_delegate, + ac->msg, + &ac->msg->exc, + &ac->out_args, + error)); /* The exit side of the invoke must not be aborted as it would leave the runtime in an undefined state */ mono_threads_begin_abort_protected_block (); if (!ac->msg->exc) { MonoException *ex = mono_error_convert_to_exception (error); - ac->msg->exc = (MonoObject *)ex; + MONO_OBJECT_SETREF_INTERNAL (ac->msg, exc, (MonoObject *)ex); } else { mono_error_cleanup (error); } - MONO_OBJECT_SETREF_INTERNAL (ac, res, res); + MONO_OBJECT_SETREF_INTERNAL (ac, res, MONO_HANDLE_RAW (res)); + + MonoObjectHandle handle = MONO_HANDLE_NEW (MonoObject, NULL); // Create handle outside of lock. mono_monitor_enter_internal ((MonoObject*) ares); ares->completed = 1; - if (ares->handle) + if (ares->handle) { + MONO_HANDLE_ASSIGN_RAW (handle, ares->handle); wait_event = mono_wait_handle_get_handle ((MonoWaitHandle*) ares->handle); + } mono_monitor_exit_internal ((MonoObject*) ares); if (wait_event != NULL) mono_w32event_set (wait_event); error_init (error); //the else branch would leave it in an undefined state - if (ac->cb_method) + if (ac->cb_method) { + MONO_HANDLE_NEW (MonoDelegate, ac->cb_target); mono_runtime_invoke_checked (ac->cb_method, ac->cb_target, (gpointer*) &ares, error); + } mono_threads_end_abort_protected_block (); - if (mono_error_set_pending_exception (error)) - return NULL; + return_val_if_nok (error, NULL_HANDLE); } - return res; } @@ -8390,8 +8409,10 @@ mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, MonoObject } #endif -MonoObject * -mono_message_invoke (MonoObject *target, MonoMethodMessage *msg, +// FIXME inline in the only caller +static MonoObject* +mono_message_invoke (MonoThreadInfo *mono_thread_info_current_var, + MonoObject *target, MonoMethodMessage *msg, MonoObject **exc, MonoArray **out_args, MonoError *error) { MONO_REQ_GC_UNSAFE_MODE; @@ -8408,9 +8429,16 @@ mono_message_invoke (MonoObject *target, MonoMethodMessage *msg, #ifndef DISABLE_REMOTING if (target && mono_object_is_transparent_proxy (target)) { MonoTransparentProxy* tp = (MonoTransparentProxy *)target; - if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) { + + gboolean const is_contextbound = mono_class_is_contextbound (tp->remote_class->proxy_class); + + MonoObject* const context = is_contextbound ? MONO_HANDLE_RAW (MONO_HANDLE_NEW (MonoObject, (MonoObject*)mono_context_get ())) : NULL; + + if (is_contextbound && tp->rp->context == context) { target = tp->rp->unwrapped_server; + MONO_HANDLE_NEW (MonoObject, target); } else { + MONO_HANDLE_NEW (MonoRealProxy, tp->rp); return mono_remoting_invoke ((MonoObject *)tp->rp, msg, exc, out_args, error); } } @@ -8439,17 +8467,23 @@ mono_message_invoke (MonoObject *target, MonoMethodMessage *msg, return_val_if_nok (error, NULL); arr = mono_array_new_specific_checked (vt, outarg_count, error); return_val_if_nok (error, NULL); + MONO_HANDLE_NEW (MonoArray, arr); mono_gc_wbarrier_generic_store_internal (out_args, (MonoObject*) arr); *exc = NULL; + MONO_HANDLE_NEW (MonoArray, msg->args); MonoObject *ret = mono_runtime_try_invoke_array (method, m_class_is_valuetype (method->klass)? mono_object_unbox_internal (target): target, msg->args, exc, error); return_val_if_nok (error, NULL); + MONO_HANDLE_NEW (MonoObject, ret); + + MonoObjectHandle argh = MONO_HANDLE_NEW (MonoObject, NULL); for (i = 0, j = 0; i < sig->param_count; i++) { if (sig->params [i]->byref) { MonoObject* arg; arg = (MonoObject *)mono_array_get_internal (msg->args, gpointer, i); + MONO_HANDLE_ASSIGN_RAW (argh, arg); mono_array_setref_internal (*out_args, j, arg); j++; } @@ -9068,7 +9102,6 @@ mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField gboolean mono_store_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer val, MonoError *error) { - MONO_REQ_GC_UNSAFE_MODE; error_init (error); -- 2.7.4