Add support for -XX:+EnableDynamicAgentLoading

[tajila]

Currently, j9 supports dynamic loading agents by default.

The capabilities required for agents are:

J9_EXTENDED_RUNTIME_OSR_SAFE_POINT
J9_EXTENDED_RUNTIME_ENABLE_HCR

These are currently enabled all the time.

We need to put default enablement of these capabilities under the EnableDynamicAgentLoading flag. This will make it possible to turn off EnableDynamicAgentLoading in a future release if it is required in a future release. For now EnableDynamicAgentLoading can remain enabled by default. This will change likely in JDK21.

Additionally, we need to detect jvm agents attached are startup. We can look at createAgentLibrary( and lazily add the OSR/HCR flags when this occurs.

We should add a runtime flag, for dynamic agent loading, this can be used to check if an agent is allowed to be loading at runtime.

The end result is:

1. When EnableDynamicAgentLoading is enabled, OSR/HCR flags are enable and dynamic agent loading is also enabled.
2. When EnableDynamicAgentLoading is disabled, OSR/HCR is only enabled when agents are attached at startup. Dynamic loading of agents is disabled.

[JasonFengJ9]

JEP 261: Module System proposed -XX:[+|-]EnableDynamicAgentLoading
The dynamic loading of JVM TI agents will be disabled by default in a future release. To prepare for that change we recommend that applications that allow dynamic agents start using the option -XX:+EnableDynamicAgentLoading to enable that loading explicitly. The option -XX:-EnableDynamicAgentLoading disables dynamic agent loading.

This change prevents the AttachAPI from loading an agent into a JVM after startup

openj9/runtime/vm/BytecodeInterpreter.hpp

Lines 4773 to 4775 in 11eb3b7

	/* openj9.internal.tools.attach.target.Attachment: private native int loadAgentLibraryImpl(ClassLoader loader, String agentLibrary, String options, boolean decorate); */
	VMINLINE VM_BytecodeAction
	inlAttachmentLoadAgentLibraryImpl(REGISTER_ARGS_LIST)

which invokes

openj9/runtime/jvmti/jvmtiStartup.c

Lines 556 to 563 in 11eb3b7

	* Load a JVMTI agent at run time and call the Agent_OnAttach_L/Agent_OnAttach function
	* @param vm Java VM
	* @param library library name. Must be non-null.
	* @param options options, if any. May be null.
	* @return JNI_ERR, JNI_OK
	*/
	I_32 JNICALL
	loadAgentLibraryOnAttach(struct J9JavaVM * vm, const char * library, const char *options, UDATA decorate)

[dnakamura]

Prototype for command line option is at #17215. @JasonFengJ9 are you saying we should also error out when attempting to load an agent? If so is it sufficient to check the J9_EXTENDED_RUNTIME_OSR_SAFE_POINT and J9_EXTENDED_RUNTIME_ENABLE_HCR? Or should we be adding a new runtime flag? (since its possible to disable either of those flags individually without -XX:-EnableDynamicAgentLoading)

[JasonFengJ9]

Or should we be adding a new runtime flag? (since its possible to disable either of those flags individually without -XX:-EnableDynamicAgentLoading)

I think a new runtime flag is required.

[fengxue-IS]

-XX:[+/-]EnableDynamicAgentLoading should not affect how HCR and OSR work and will need a new runtime flag or internal java property. Looking at the purposed JEP draft: Prepare to Restrict The Dynamic Loading of Agents this option is simply a way of disabling the Attach API.

As OpenJ9's agentload code only have a single entry point in JCL, could just add new check for the flag/property at

openj9/jcl/src/java.base/share/classes/openj9/internal/tools/attach/target/Attachment.java

Lines 369 to 383 in 84d3914

	String loadAgentLibrary(String agentLibrary, String options,
	boolean decorate) {
	IPC.logMessage("loadAgentLibrary " + agentLibrary + ':' + options + " decorate=" + decorate); //$NON-NLS-1$ //$NON-NLS-2$
	ClassLoader loader = java.lang.ClassLoader.getSystemClassLoader();
	int status = loadAgentLibraryImpl(loader ,agentLibrary, options, decorate);
	if (0 != status) {
	if (-1 == status) {
	return Response.EXCEPTION_AGENT_LOAD_EXCEPTION + ' '
	+ agentLibrary + ':' + options;
	} else {
	return Response.EXCEPTION_AGENT_INITIALIZATION_EXCEPTION
	+ status;
	}
	}
	return null;

This would be a requirement if we want enable optimization to allow VirtualThread to skip notifyJvmti* calls when no JVMTI agent requires such capabilities.

[tajila]

From a functional perspective, all we need to do is disable dynamic loading of agents. However, given that in J9 an agent can always be dynamically loaded we need to support OSR/HCR all the time. The removal of this capability lets us disable HCR/OSR as default JVM capabilities and only apply them when they are needed which is important from a performance perspective. This issue was created as an attempt to do some early refactoring and combine default enablement of HCR/OSR under EnableDynamicAgentLoading

[tajila]

I've updated the description to be more clear

[keithc-ca]

given that in J9 an agent can always be dynamically loaded

Please explain how this is not in fundamental conflict with the intent of -XX:-EnableDynamicAgentLoading?

[tajila]

Please explain how this is not in fundamental conflict with the intent of -XX:-EnableDynamicAgentLoading?

The fact that J9 always allows dynamic agent loading is not spec behaviour. In fact, it hasn't always been J9 behaviour. In the early releases of JDK8 this was not the case.

The new proposed options standardizes this behaviour.

[keithc-ca]

Just to be crystal clear, so using -XX:-EnableDynamicAgentLoading would disallow dynamic agent loading (period)?

[tajila]

Just to be crystal clear, so using -XX:-EnableDynamicAgentLoading would disallow dynamic agent loading (period)?

yes, thats correct

[tajila]

Closing as initial PR is merged