From f36aeb7ca3f8450df77594d6a15e253f450941bd Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Thu, 30 Aug 2018 17:24:11 -0700 Subject: [PATCH] Add startup hook in System.Private.CoreLib (dotnet/coreclr#19486) * Add startup hook in System.Private.CoreLib ProcessStartupHooks can be called from the host before the user's Main entry point. It receives a list of dlls and types containing Initialize() methods that will be called, making it possible to inject managed code early during startup. * Allow ! in assembly path for startup hook and other changes Also: - Report full assembly path when startup hook assembly is not found - Remove unnecessary assert - use Type.Delimiter instead of "." * Use C# 7 tuple syntax and remove assert * Improve error handling Throw MissingMethodException only when there aren't any Initialize methods at all. When there are Initialize methods with incorrect signatures (parameters, return type, visibility, or instance methods), throw invalid signature error. This should improve diagnosability of this feature. * Remove eager check for missing startup hook assemblies * Require full assembly path and use Split(char) overload. * Remove startup hook type syntax The type is now required to be "StartupHook" (in the global namespace). * Add assembly path to startup signature exception With a hard-coded type name, printing the type.method of the startup hook in the exception will no longer be much of an aid in debugging startup hook signature issues. Adding the assembly path makes it clear which startup hook had the problem. * Use const strings * Call startup hook inside ExecuteMainMethod This way it will be called when the application is executed, but not during other uses of hosting apis that go through coreclr_create_delegate. This change will ensure that the threading state is set based on attributes in the main method, before the startup hooks run. * Run startup hooks after setting root assembly and other fixes - Run startup hooks after setting the appdomain's root assembly (visible in Assembly.GetEntryAssembly() - Make the class static - Remove debug output - Don't allocate an empty ARG_SLOT array * Allow non-public Initialize method, adjust coding style * Remove overly-specific assert Commit migrated from https://github.com/dotnet/coreclr/commit/1c47703a3d548e5f3293a11d98747dd83bf429f1 --- .../System.Private.CoreLib/Resources/Strings.resx | 6 ++ .../System.Private.CoreLib.csproj | 1 + .../src/System/StartupHookProvider.cs | 120 +++++++++++++++++++++ src/coreclr/src/vm/assembly.cpp | 19 +++- src/coreclr/src/vm/mscorlib.h | 3 + 5 files changed, 148 insertions(+), 1 deletion(-) create mode 100644 src/coreclr/src/System.Private.CoreLib/src/System/StartupHookProvider.cs diff --git a/src/coreclr/src/System.Private.CoreLib/Resources/Strings.resx b/src/coreclr/src/System.Private.CoreLib/Resources/Strings.resx index 0a3b1b5..403e5fc 100644 --- a/src/coreclr/src/System.Private.CoreLib/Resources/Strings.resx +++ b/src/coreclr/src/System.Private.CoreLib/Resources/Strings.resx @@ -1249,6 +1249,12 @@ The specified serialized string '{0}' is not supported. + + The syntax of the startup hook variable was invalid. + + + The signature of the startup hook '{0}' in assembly '{1}' was invalid. It must be 'public static void Initialize()'. + An undefined TimeSpanStyles value is being used. diff --git a/src/coreclr/src/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/src/System.Private.CoreLib/System.Private.CoreLib.csproj index 8e8fe3e..d50c66f 100644 --- a/src/coreclr/src/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/src/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -289,6 +289,7 @@ + diff --git a/src/coreclr/src/System.Private.CoreLib/src/System/StartupHookProvider.cs b/src/coreclr/src/System.Private.CoreLib/src/System/StartupHookProvider.cs new file mode 100644 index 0000000..cc6f8d4 --- /dev/null +++ b/src/coreclr/src/System.Private.CoreLib/src/System/StartupHookProvider.cs @@ -0,0 +1,120 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics; +using System.IO; +using System.Collections.Generic; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Runtime.Loader; + +namespace System +{ + internal static class StartupHookProvider + { + private const string StartupHookTypeName = "StartupHook"; + private const string InitializeMethodName = "Initialize"; + + // Parse a string specifying a list of assemblies and types + // containing a startup hook, and call each hook in turn. + private static void ProcessStartupHooks() + { + string startupHooksVariable = (string)AppContext.GetData("STARTUP_HOOKS"); + if (startupHooksVariable == null) + { + return; + } + + // Parse startup hooks variable + string[] startupHooks = startupHooksVariable.Split(Path.PathSeparator); + foreach (string startupHook in startupHooks) + { + if (String.IsNullOrEmpty(startupHook)) + { + throw new ArgumentException(SR.Argument_InvalidStartupHookSyntax); + } + if (PathInternal.IsPartiallyQualified(startupHook)) + { + throw new ArgumentException(SR.Argument_AbsolutePathRequired); + } + } + + // Call each hook in turn + foreach (string startupHook in startupHooks) + { + CallStartupHook(startupHook); + } + } + + // Load the specified assembly, and call the specified type's + // "static void Initialize()" method. + private static void CallStartupHook(string assemblyPath) + { + Debug.Assert(!String.IsNullOrEmpty(assemblyPath)); + Debug.Assert(!PathInternal.IsPartiallyQualified(assemblyPath)); + + Assembly assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath); + Debug.Assert(assembly != null); + Type type = assembly.GetType(StartupHookTypeName, throwOnError: true); + + // Look for a static method without any parameters + MethodInfo initializeMethod = type.GetMethod(InitializeMethodName, + BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, + null, // use default binder + Type.EmptyTypes, // parameters + null); // no parameter modifiers + + bool wrongSignature = false; + if (initializeMethod == null) + { + // There weren't any static methods without + // parameters. Look for any methods with the correct + // name, to provide precise error handling. + try + { + // This could find zero, one, or multiple methods + // with the correct name. + initializeMethod = type.GetMethod(InitializeMethodName, + BindingFlags.Public | BindingFlags.NonPublic | + BindingFlags.Static | BindingFlags.Instance); + } + catch (AmbiguousMatchException) + { + // Found multiple + Debug.Assert(initializeMethod == null); + wrongSignature = true; + } + if (initializeMethod != null) + { + // Found one + wrongSignature = true; + } + else + { + // Didn't find any + throw new MissingMethodException(StartupHookTypeName, InitializeMethodName); + } + } + else if (initializeMethod.ReturnType != typeof(void)) + { + wrongSignature = true; + } + + if (wrongSignature) + { + throw new ArgumentException(SR.Format(SR.Argument_InvalidStartupHookSignature, + StartupHookTypeName + Type.Delimiter + InitializeMethodName, + assemblyPath)); + } + + Debug.Assert(initializeMethod != null && + initializeMethod.IsStatic && + initializeMethod.ReturnType == typeof(void) && + initializeMethod.GetParameters().Length == 0); + + initializeMethod.Invoke(null, null); + } + } +} diff --git a/src/coreclr/src/vm/assembly.cpp b/src/coreclr/src/vm/assembly.cpp index 0eb1e2a..02781aa 100644 --- a/src/coreclr/src/vm/assembly.cpp +++ b/src/coreclr/src/vm/assembly.cpp @@ -1715,6 +1715,21 @@ static void RunMainPost() } } +static void RunStartupHooks() +{ + CONTRACTL + { + THROWS; + GC_TRIGGERS; + MODE_COOPERATIVE; + INJECT_FAULT(COMPlusThrowOM();); + } + CONTRACTL_END; + + MethodDescCallSite processStartupHooks(METHOD__STARTUP_HOOK_PROVIDER__PROCESS_STARTUP_HOOKS); + processStartupHooks.Call(NULL); +} + INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThreads) { CONTRACTL @@ -1759,12 +1774,14 @@ INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThre RunMainPre(); - // Set the root assembly as the assembly that is containing the main method // The root assembly is used in the GetEntryAssembly method that on CoreCLR is used // to get the TargetFrameworkMoniker for the app AppDomain * pDomain = pThread->GetDomain(); pDomain->SetRootAssembly(pMeth->GetAssembly()); + + RunStartupHooks(); + hr = RunMain(pMeth, 1, &iRetVal, stringArgs); } } diff --git a/src/coreclr/src/vm/mscorlib.h b/src/coreclr/src/vm/mscorlib.h index c1b904c..0115683 100644 --- a/src/coreclr/src/vm/mscorlib.h +++ b/src/coreclr/src/vm/mscorlib.h @@ -846,6 +846,9 @@ DEFINE_FIELD_U(rgiColumnNumber, StackFrameHelper, rgiColumnNumber) DEFINE_FIELD_U(rgiLastFrameFromForeignExceptionStackTrace, StackFrameHelper, rgiLastFrameFromForeignExceptionStackTrace) DEFINE_FIELD_U(iFrameCount, StackFrameHelper, iFrameCount) +DEFINE_CLASS(STARTUP_HOOK_PROVIDER, System, StartupHookProvider) +DEFINE_METHOD(STARTUP_HOOK_PROVIDER, PROCESS_STARTUP_HOOKS, ProcessStartupHooks, SM_RetVoid) + DEFINE_CLASS(STREAM, IO, Stream) DEFINE_METHOD(STREAM, BEGIN_READ, BeginRead, IM_ArrByte_Int_Int_AsyncCallback_Object_RetIAsyncResult) DEFINE_METHOD(STREAM, END_READ, EndRead, IM_IAsyncResult_RetInt) -- 2.7.4