[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski edited comment on JBTM-2423 at 9/16/15 4:29 AM:
---------------------------------------------------------------
checking
was (Author: tomekadamski):
https://issues.jboss.org/secure/ViewProfile.jspa?name=mmusgrov checking
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove commented on JBTM-2423:
----------------------------------------
[~tomekadamski] During the wildfly subsystem reload operation does org.jboss.as.txn.service.ArjunaRecoveryManagerService.stop get called. If it isn't called then that is where the bug is and if it is called then we need to debug why it doesn't clean up correctly.
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski edited comment on JBTM-2423 at 9/15/15 5:33 PM:
---------------------------------------------------------------
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method neither as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving in the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now so we can discuss it - will test it and paste it in few minutes if it passes the tests (and tomorrow if it doesn't :) ).
was (Author: tomekadamski):
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method neither as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving in the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski edited comment on JBTM-2423 at 9/15/15 5:32 PM:
---------------------------------------------------------------
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method neither as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving in the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
was (Author: tomekadamski):
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method neither as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski edited comment on JBTM-2423 at 9/15/15 5:32 PM:
---------------------------------------------------------------
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method neither as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
was (Author: tomekadamski):
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method too as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski edited comment on JBTM-2423 at 9/15/15 5:31 PM:
---------------------------------------------------------------
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes above destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method too as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
was (Author: tomekadamski):
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes about destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method too as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski edited comment on JBTM-2423 at 9/15/15 5:31 PM:
---------------------------------------------------------------
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes about destruction of POA and shutdown of ORB were remove from ORBRunner class and:
{code}
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
{code}
code was added to ORBs shutdown method. The problem is that noone calls shutdown method too as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
was (Author: tomekadamski):
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes about destruction of POA and shutdown of ORB were remove from ORBRunner class and:
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
code was added to ORBs shutdown method. The problem is that noone calls shutdown method too as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski commented on JBTM-2423:
--------------------------------------
The issue returned in WFLY-5261. I was looking at the problem today. The problem is that shutdown hooks are not executed - among them is JavaIdlRCShutdown - lack of is execution causes the error in WFLY-5261.
In the changes about destruction of POA and shutdown of ORB were remove from ORBRunner class and:
// Ensure destroy is called on the root OA so that any pre/post destroy hooks get called
// Normally we expect whoever called shutdown to have done this however destroy is
// safe to call multiple times
OA.getRootOA(this).destroy();
code was added to ORBs shutdown method. The problem is that noone calls shutdown method too as it was executed only from ORBRunner class. On the other when we execute shutdown method from ORBRunner class we are violating specification which also leads to a problems that we were solving at the first place.
My suggestion would be to try perform destruction/shutdown in ORBRunner but only of the wrappers (without delegation to underlying ORB/POAs as we are sure they are already destroyed when ORBRunner runs).
I'm preparing quick test of that solution now - will test it and paste it in few minutes if it passes the test (and tomorrow if it doesn't :) ).
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove commented on JBTM-2423:
----------------------------------------
[~tomekadamski] please will you add a comment explaining why you have reopened this JIRA
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Tomasz Adamski (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Tomasz Adamski reassigned JBTM-2423:
------------------------------------
Assignee: Tomasz Adamski (was: Michael Musgrove)
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Tomasz Adamski
> Fix For: 5.2.0
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.4.11#64026)
8 years, 7 months