Skip to content

8252871: fatal error: must own lock JvmtiThreadState_lock #60

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 1 commit into from

Conversation

robehn
Copy link
Contributor

@robehn robehn commented Sep 7, 2020

When these two methods (set_frame_pop/clear_frame_pop) are called in a handshake the requesting thread will have lock the JvmtiThreadState_lock.
But the thread executing one of these in the handshake may not be the owner.
So we only check that JvmtiThreadState_lock is locked.

When verifying the callers to these methods I notice "clear_to_frame_pop" was unused, so instead of fixing it I remove it.

Passes testing locally, still running T3 and T7.

Now passed!


Progress

  • Change must not contain extraneous whitespace
  • Commit message must refer to an issue
  • Change must be properly reviewed

Issues

  • JDK-8252871: fatal error: must own lock JvmtiThreadState_lock
  • JDK-8252816: JvmtiEnvThreadState::clear_to_frame_pop() is not used

Reviewers

Download

$ git fetch https://git.openjdk.java.net/jdk pull/60/head:pull/60
$ git checkout pull/60

@bridgekeeper
Copy link

bridgekeeper bot commented Sep 7, 2020

👋 Welcome back rehn! A progress list of the required criteria for merging this PR into master will be added to the body of your pull request. There are additional pull request commands available for use with this pull request.

@openjdk
Copy link

openjdk bot commented Sep 7, 2020

@robehn The following labels will be automatically applied to this pull request: hotspot serviceability.

When this pull request is ready to be reviewed, an RFR email will be sent to the corresponding mailing lists. If you would like to change these labels, use the /label (add|remove) "label" command.

@openjdk openjdk bot added serviceability serviceability-dev@openjdk.org hotspot hotspot-dev@openjdk.org labels Sep 7, 2020
@robehn robehn marked this pull request as ready for review September 7, 2020 18:53
@openjdk openjdk bot added the rfr Pull request is ready for review label Sep 7, 2020
@mlbridge
Copy link

mlbridge bot commented Sep 7, 2020

Webrevs

Copy link
Member

@YaSuenag YaSuenag left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for catching up this. Looks good.

@openjdk
Copy link

openjdk bot commented Sep 7, 2020

@robehn This change now passes all automated pre-integration checks. In addition to the automated checks, the change must also fulfill all project specific requirements

After integration, the commit message will be:

8252871: fatal error: must own lock JvmtiThreadState_lock
8252816: JvmtiEnvThreadState::clear_to_frame_pop() is not used

Reviewed-by: ysuenaga, dholmes
  • If you would like to add a summary, use the /summary command.
  • To credit additional contributors, use the /contributor command.
  • To add additional solved issues, use the /issue command.

Since the source branch of this PR was last updated there have been 13 commits pushed to the master branch:

  • bf5da0c: 8252897: Minor .jcheck/conf update
  • 7600274: 8252859: Inconsistent use of alpha in class AbsSeq
  • 4fb1980: 8252853: AArch64: gc/shenandoah/TestVerifyJCStress.java fails intermittently with C1
  • 73ba3ae: 8252500: ZGC on aarch64: Unable to allocate heap for certain Linux kernel configurations
  • 5dd1ead: 8252767: URLConnection.setRequestProperty throws IllegalAccessError
  • 2cceeed: 8166554: Avoid compilation blocking in OverloadCompileQueueTest.java
  • 188b0bc: 8252868: Clean up unused function from G1MMUTracker
  • 891886b: 8252887: Zero VM is broken after JDK-8252661
  • 7686e87: 8250968: Symlinks attributes not preserved when using jarsigner on zip files
  • 8d6d43c: 8251193: bin/idea.sh is generating wrong folder definitions for JVMCI modules
  • ... and 3 more: https://git.openjdk.java.net/jdk/compare/e0c8d4420c8e1a84581927cf77314498b8e5aa52...master

As there are no conflicts, your changes will automatically be rebased on top of these commits when integrating. If you prefer to avoid automatic rebasing, please merge master into your branch, and then specify the current head hash when integrating, like this: /integrate bf5da0c778f2cbc8c1b8568ca16c4bf51f7972b5.

➡️ To integrate this PR with the above commit message to the master branch, type /integrate in a new comment.

@openjdk openjdk bot added the ready Pull request is ready to be integrated label Sep 7, 2020
@mlbridge
Copy link

mlbridge bot commented Sep 8, 2020

Mailing list message from David Holmes on hotspot-dev:

Hi Robbin,

On 8/09/2020 4:56 am, Robbin Ehn wrote:

When these two methods (set_frame_pop/clear_frame_pop) are called in a handshake the requesting thread will have lock
the JvmtiThreadState_lock. But the thread executing one of these in the handshake may not be the owner.

Ouch! We continue to get bitten by the fact the executor of a handshake
operation is not known a-priori. :(

So we only check that JvmtiThreadState_lock is locked.

That avoids the problem but it is not really a sufficient check - we
need to know that it is the handshaker thread that owns the lock and
that it acquired it purely for the purpose of this handshake operation!

More importantly this issue shows that the locking code is in fact
incorrect. We are on very dangerous ground if we are going to allow
locks to be "proxied" in this fashion! This is akin to reintroducing
"sneaky locks"!

If a handshake operation can be executed by either the target thread or
the handshaker thread, and locks are required, then they will have to be
acquired in the context of the handshake operation. If we can't do that
because of potential deadlocks in the handshake mechanism then I feel
that handshakes have a serious flaw that needs to be rectified. Perhaps
we need a way to force the operation to be executed by the handshaker so
that they can setup the right execution environment prior to the handshake?

When verifying the callers to these methods I notice "clear_to_frame_pop" was unused, so instead of fixing it I remove
it.

There is already a bug for that:

https://bugs.openjdk.java.net/browse/JDK-8252816

so if this proceeds you should add that issue to the PR.

Thanks,
David
-----

@robehn
Copy link
Contributor Author

robehn commented Sep 8, 2020

Hi David,

When these two methods (set_frame_pop/clear_frame_pop) are called in a handshake the requesting thread will have lock
the JvmtiThreadState_lock. But the thread executing one of these in the handshake may not be the owner.

Ouch! We continue to get bitten by the fact the executor of a handshake
operation is not known a-priori. :(

We could add this. But I would prefer not doing it in this bug fix.

So we only check that JvmtiThreadState_lock is locked.

That avoids the problem but it is not really a sufficient check - we
need to know that it is the handshaker thread that owns the lock and
that it acquired it purely for the purpose of this handshake operation!

Right now we know that because I traced the code :)

As I said I can make the requesting thread known to execution thread,
but I would really prefer not doing that in this bug fix.

More importantly this issue shows that the locking code is in fact
incorrect. We are on very dangerous ground if we are going to allow
locks to be "proxied" in this fashion! This is akin to reintroducing
"sneaky locks"!

A problem is that we use a safepoiting global lock to protect per thread resource.
The way we get around this with safepoints is:
"assert_locked_or_safepoint" (assert may be passed by a non-JavaThread or JavaThread in blocked/native without lock during a safepoint (safepoint + VM thread would fix that))
Which have this in it:
// see if invoker of VM operation owns it
VM_Operation* op = VMThread::vm_operation();
if (op != NULL && op->calling_thread() == lock->owner()) return;

So we already have proxied locks and in other cases just avoiding them (by just checking if at safepoint).

And as I said a few times now, I said I can make the requesting thread known to execution thread,
but I would really prefer not doing that in this bug fix.

If a handshake operation can be executed by either the target thread or
the handshaker thread, and locks are required, then they will have to be
acquired in the context of the handshake operation. If we can't do that
because of potential deadlocks in the handshake mechanism then I feel
that handshakes have a serious flaw that needs to be rectified. Perhaps
we need a way to force the operation to be executed by the handshaker so
that they can setup the right execution environment prior to the handshake?

The problem is that it's a safepointing lock.
Only executing the handshake by requester is an interesting idea, I'll investigate that.

When verifying the callers to these methods I notice "clear_to_frame_pop" was unused, so instead of fixing it I remove
it.

There is already a bug for that:

https://bugs.openjdk.java.net/browse/JDK-8252816

so if this proceeds you should add that issue to the PR.

Ok, I'll do that.

Thanks for having a look, let me know howto proceed.

Thanks,
David

@robehn
Copy link
Contributor Author

robehn commented Sep 8, 2020

/issue add JDK-8252816

@openjdk
Copy link

openjdk bot commented Sep 8, 2020

@robehn
Adding additional issue to issue list: 8252816: JvmtiEnvThreadState::clear_to_frame_pop() is not used.

@mlbridge
Copy link

mlbridge bot commented Sep 8, 2020

Mailing list message from Robbin Ehn on hotspot-dev:

Hi David, our mail service did the wrong thing here.

This was a reply to your comment, so you should have been in To-field,
this quote above "Hi David" should not have been here, and this was a
reply your mail (via github comment).

Thanks, Robbin

On 2020-09-08 09:39, Robbin Ehn wrote:

@mlbridge
Copy link

mlbridge bot commented Sep 8, 2020

Mailing list message from David Holmes on hotspot-dev:

Hi Robbin,

On 8/09/2020 5:39 pm, Robbin Ehn wrote:

Hi David,

When these two methods (set_frame_pop/clear_frame_pop) are called in a handshake the requesting thread will have lock
the JvmtiThreadState_lock. But the thread executing one of these in the handshake may not be the owner.

Ouch! We continue to get bitten by the fact the executor of a handshake
operation is not known a-priori. :(

We could add this. But I would prefer not doing it in this bug fix.

Okay we can put in the current proposed fix to get the test working
again. Please file a new bug to fix the underlying locking problem.

So we only check that JvmtiThreadState_lock is locked.

That avoids the problem but it is not really a sufficient check - we
need to know that it is the handshaker thread that owns the lock and
that it acquired it purely for the purpose of this handshake operation!

Right now we know that because I traced the code :)

I'm sure you get my point though. :)

As I said I can make the requesting thread known to execution thread,
but I would really prefer not doing that in this bug fix.

More importantly this issue shows that the locking code is in fact
incorrect. We are on very dangerous ground if we are going to allow
locks to be "proxied" in this fashion! This is akin to reintroducing
"sneaky locks"!

A problem is that we use a safepoiting global lock to protect per thread resource.
The way we get around this with safepoints is:
"assert_locked_or_safepoint" (assert may be passed by a non-JavaThread or JavaThread in blocked/native without lock
during a safepoint (safepoint + VM thread would fix that)) Which have this in it:
// see if invoker of VM operation owns it
VM_Operation* op = VMThread::vm_operation();
if (op != NULL && op->calling_thread() == lock->owner()) return;

So we already have proxied locks and in other cases just avoiding them (by just checking if at safepoint).

Okay ... we know that the VMThread and safepoint VMops are special, and
always have been special, and people absolutely loathe the things we did
in supporting that special-ness and we (well you, Erik, Patricio, Dan)
have been working hard to get rid of a lot of that special code. So I
can't accept an argument that it is okay to take VMThread/VMop special
behaviour (e.g. lock proxying) and now spread it around to make other
special cases.

And as I said a few times now, I said I can make the requesting thread known to execution thread,
but I would really prefer not doing that in this bug fix.

Understood.

I have a general concern with locking in relation to handshakes, that we
cannot actually get rid of all the special handling that pertained to
safepoints (safepoint-check-always/never, lock ranking) just because we
now use handshakes. We have the same kinds of deadlock concerns if a
handshake operation tries to take a lock and might block the thread. So
same problem as safepoints and locks but no supporting code to try and
help us with that.

So if we cannot simply grab the necessary locks as part of the handshake
operation, then we need a way to ensure locking correctness prior to the
op - and the simplest seems to be that the handshaker does the necessary
locking and the handshake mechanism allows us to ensure the handshaker
executes the operation not the target.

Thanks,
David
-----

@robehn
Copy link
Contributor Author

robehn commented Sep 8, 2020

Hi David,

Okay we can put in the current proposed fix to get the test working
again. Please file a new bug to fix the underlying locking problem.

I created https://bugs.openjdk.java.net/browse/JDK-8252902
Please feel free to add sub-task, edit or change if I missed anything.

Thanks, Robbin

So we only check that JvmtiThreadState_lock is locked.

That avoids the problem but it is not really a sufficient check - we
need to know that it is the handshaker thread that owns the lock and
that it acquired it purely for the purpose of this handshake operation!

Right now we know that because I traced the code :)

I'm sure you get my point though. :)

As I said I can make the requesting thread known to execution thread,
but I would really prefer not doing that in this bug fix.

More importantly this issue shows that the locking code is in fact
incorrect. We are on very dangerous ground if we are going to allow
locks to be "proxied" in this fashion! This is akin to reintroducing
"sneaky locks"!

A problem is that we use a safepoiting global lock to protect per thread resource.
The way we get around this with safepoints is:
"assert_locked_or_safepoint" (assert may be passed by a non-JavaThread or JavaThread in blocked/native without lock
during a safepoint (safepoint + VM thread would fix that)) Which have this in it:
// see if invoker of VM operation owns it
VM_Operation* op = VMThread::vm_operation();
if (op != NULL && op->calling_thread() == lock->owner()) return;
So we already have proxied locks and in other cases just avoiding them (by just checking if at safepoint).

Okay ... we know that the VMThread and safepoint VMops are special, and
always have been special, and people absolutely loathe the things we did
in supporting that special-ness and we (well you, Erik, Patricio, Dan)
have been working hard to get rid of a lot of that special code. So I
can't accept an argument that it is okay to take VMThread/VMop special
behaviour (e.g. lock proxying) and now spread it around to make other
special cases.

And as I said a few times now, I said I can make the requesting thread known to execution thread,
but I would really prefer not doing that in this bug fix.

Understood.

I have a general concern with locking in relation to handshakes, that we
cannot actually get rid of all the special handling that pertained to
safepoints (safepoint-check-always/never, lock ranking) just because we
now use handshakes. We have the same kinds of deadlock concerns if a
handshake operation tries to take a lock and might block the thread. So
same problem as safepoints and locks but no supporting code to try and
help us with that.

So if we cannot simply grab the necessary locks as part of the handshake
operation, then we need a way to ensure locking correctness prior to the
op - and the simplest seems to be that the handshaker does the necessary
locking and the handshake mechanism allows us to ensure the handshaker
executes the operation not the target.

Thanks,
David

@robehn
Copy link
Contributor Author

robehn commented Sep 8, 2020

/integrate

@openjdk openjdk bot closed this Sep 8, 2020
@openjdk openjdk bot added integrated Pull request has been integrated and removed ready Pull request is ready to be integrated rfr Pull request is ready for review labels Sep 8, 2020
@openjdk
Copy link

openjdk bot commented Sep 8, 2020

@robehn Since your change was applied there have been 13 commits pushed to the master branch:

  • bf5da0c: 8252897: Minor .jcheck/conf update
  • 7600274: 8252859: Inconsistent use of alpha in class AbsSeq
  • 4fb1980: 8252853: AArch64: gc/shenandoah/TestVerifyJCStress.java fails intermittently with C1
  • 73ba3ae: 8252500: ZGC on aarch64: Unable to allocate heap for certain Linux kernel configurations
  • 5dd1ead: 8252767: URLConnection.setRequestProperty throws IllegalAccessError
  • 2cceeed: 8166554: Avoid compilation blocking in OverloadCompileQueueTest.java
  • 188b0bc: 8252868: Clean up unused function from G1MMUTracker
  • 891886b: 8252887: Zero VM is broken after JDK-8252661
  • 7686e87: 8250968: Symlinks attributes not preserved when using jarsigner on zip files
  • 8d6d43c: 8251193: bin/idea.sh is generating wrong folder definitions for JVMCI modules
  • ... and 3 more: https://git.openjdk.java.net/jdk/compare/e0c8d4420c8e1a84581927cf77314498b8e5aa52...master

Your commit was automatically rebased without conflicts.

Pushed as commit 704f784.

💡 You may see a message that your pull request was closed with unmerged commits. This can be safely ignored.

@robehn robehn deleted the 8252871-wrong-assert branch September 8, 2020 13:47
caojoshua pushed a commit to caojoshua/jdk that referenced this pull request Jul 26, 2023
We should use interface as_virtual/as_escaped after alias refactor.

Co-authored-by: Xin Liu <xxinliu@amazon.com>
dansmithcode pushed a commit to dansmithcode/jdk that referenced this pull request Aug 31, 2024
* Update LICENSE file

* The experimental version is aimed to refactor the tool

* verificationType mistakenly added to source code is renamed to type

* Adapted mvn bindings to at8

* Added tests to represent bad stream handling in jdec and correctone in jdis

* Made jdec to write output to proper toolOutput instead of bad logOutput

* 7903208: [Jasm] Add support for generics (the Signature attribute)

* 7902888: Excess entries in BootstrapMethods with the same bsm, bsmKind, bsmArgs

* Replaced hardcoded String[] args, by varargs String... where reasonable

Once the "tool" mandatory array memebr was removed from each tool's main
method, and considering calls from libraries, and form tests where the
argument is very often just one file, or more readable "a1", a2"...
without new String[]{} declaration, changed those String[] enforcing
headers to more benevolent String...

* Intentionally removed ACC_SUPER class modifier was causing hotswap to fail

When jasm's  disasm, modify, asm cycle output binary was used for class
hotswap, remote JDK was not accepting it with java.lang.UnsupportedOperationException:
class redefinition failed: attempted to change the class modifiers
beacuse of ommited supoer keyword (although it have already no real
reason)

This patch is returning the kwyword without conditions, when it was
included in original bytecode

* extended test to verify that super is not used always

if super is not in source code, then it is not in disambled code

* 7903248: jasm: FieldData.ConstantValue holds undefined reference to CP while writing fields to a class

* Added support for stdin in jdis

* stdin is now read also by jasm,jcod,jdec

more tests needed

* Removed jdis specific missleading provide method

* Tool output moved where it belongs to commons

* Removed duplicated declaration of ArrayList<ToolInput> fileList

* Changed requireNonNull message in getDataInputStream

* Added one more abstraction layer providing highly reusable byte[] based input

* Properly exiting after verson is printed

* Stream based inputs are now drained once needed, not during construction

* reworked stdin read to be initiated by -

As a side effect, files and stdin can be read together
remove dduplicated code in tests by getting class in compile time
added tests and adapted older to new behavior

* added tests if asmtools assmble itself into valid bytecode

Added two set of tests
jdec->jcoder->load
jdis->jasm->load
Both in two variants, with -g, and without

Both jdec->jcoder->load works fine
Both jdis->jasm->load now fails on three files from 278:
 /org/openjdk/asmtools/jasm/JasmEnvironment$InputFile.class, /org/openjdk/asmtools/jcoder/Jcoder.class, /org/openjdk/asmtools/jasm/Parser.class
Fail looks valid.

Unluckily, the issue where -g disassembled and back assembled
com.google.gson.Gson produce invalid bytecode was not hit

The class BruteForceHelper is reusable for any set of classes

* Naive fix for enforced dot.suffix

* repalce stdout by configurable object

This checkout is not buildable, but server as showcase for issue with
dual logging for compilers

* Replaced dualstream logger by wrapper

so it can  be later made fully customisable

* Enabled shared i18n properties via reused asmtools/i18n.props

* All four tools now use neww ToolOutput output

As a consequence, all four tools by by default prints to stdout, and
honours -d properly

* Fixed typo which casued behavior regression

found by unittests

* Refatoed tests so they can harbour resources in maven way

* Moved all logging to stderr. use -dls to return original behavior

The -dls switch  is oging to be removed once stderr is properl adapted

* Implemented library-like input and output

This commit is adding byte[]/String  input/output clasases for direct
library usage.
Added tests, advertising how simple is usage of those inputs/outputs

There are two hunks, which fixes issues ovberlooked in previous
refactorings:
 - traceln now correctly calls getOutputs
 - jdec now uses proper logger insted of accidental stderr

* Enabled -g for jcoder to be set from external code

* Temporary workaround around tests being order-sensitive

As -g is now making some disassmebld code not asemble-able back, and
order of tests is not deterministic, and Options are static, thus if -g
is now set in some test, it is not unset in other tests.

Real fix is to move Options out of static context to context of
environment as it is done for jcoder.

* Added github actions

Just for record for "act" for local testing. To run with podman based distros, several steps are ncessary. See nektos/act#303 ; especially
 * nektos/act#303 (comment)
 *  and nektos/act#303 (comment)
    *   the bind and socket
eg:
 systemctl enable --now --user podman.socket
 systemctl start --user podman.socket
 export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
 ../act/bin/act   --bind --container-daemon-socket $XDG_RUNTIME_DIR/podman/podman.sock

 To rerun the build on clean env, you have to stop and start the podman socket again

Without explicit 'mvn test' the tests are not running. Not sure why

* 7902888: Excess entries in BootstrapMethods with the same bsm, bsmKind, bsmArgs

* Fixed issue when jasm produced only one file from source with multiple ones

Added tests for this issue
Added test veryfying that the jcoder is not affected

* 7903401: jtreg fails if set of jdk tests process jasm,jdis files with defects

* 7903402: jdis: tool writes incorrect StackMapTable if the first same_frame has type 0 (openjdk#51)

* 7902888: Excess entries in BootstrapMethods with the same bsm, bsmKind, bsmArgs

* 7903401: jtreg fails if set of jdk tests process jasm,jdis files with defects

* 7903402: jdis: tool writes incorrect StackMapTable if the first same_frame has type 0

* 7902888: Excess entries in BootstrapMethods with the same bsm, bsmKind, bsmArgs

* Refactored new ToolInput/Outputs so they reside in own packages and not in original interfaces (openjdk#53)

* Refactored new ToolInput/Outputs so they reside in own packages and not in original interfaces

* Removed unused imports

* Added licence headers

* Added ajvadoc description to three main interfaces.

* Removed unnecessary guard condition before changging \ to / for fqn

* Replaced "\n" by System.lineSeparator()

* Used better names for highlighted abbrevations

* 7903405: compiler does not warn about instruction arguments that exceed allowed limits (openjdk#54)

* 7902888: Excess entries in BootstrapMethods with the same bsm, bsmKind, bsmArgs

* 7903401: jtreg fails if set of jdk tests process jasm,jdis files with defects

* 7903402: jdis: tool writes incorrect StackMapTable if the first same_frame has type 0

* 7902888: Excess entries in BootstrapMethods with the same bsm, bsmKind, bsmArgs

* 7903405: compiler does not warn about instruction arguments that exceed allowed limits

* 7903405: compiler does not warn about instruction arguments that exceed allowed limits

* Delete ToolOutput.java

* Fixed junit test for CODETOOLS-7903405 (openjdk#56)

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0 (openjdk#57)

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* Fix tabs

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0 (Part II) (openjdk#58)

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* Fix tabs

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* CODETOOLS-7903506: Asmtools: jdis prints BootstrapMethod attribute if detailed output is off (openjdk#59)

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* Fix tabs

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903506: Asmtools: jdis prints BootstrapMethod attribute if detailed output is off

* 7903509: jcoder, jasm: add option to override class file version in source file(s) (openjdk#60)

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* Fix tabs

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903509: jcoder, jasm: add option to override class file version in source file(s)

* CODETOOLS-7903531: jdis: Suppress printing comments by adding an option (openjdk#61)

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* Fix tabs

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903458: Umbrella: Preparations for switching to Asmtools 8.0

* 7903531: jdis: Suppress printing comments by adding an option

---------

Co-authored-by: Jiri Vanek <jvanek@redhat.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
hotspot hotspot-dev@openjdk.org integrated Pull request has been integrated serviceability serviceability-dev@openjdk.org
Development

Successfully merging this pull request may close these issues.

3 participants