Chromium Code Reviews
|
|
Chromium Code Reviews
Issue
2074863002:
[Reland] Worker: Protect a running debugger task from forcible worker termination (2) (Closed)
|
Created:
4 years, 6 months ago by nhiroki Modified:
4 years, 6 months ago Reviewers:
kinuko CC:
chromium-reviews, blink-reviews, kinuko+worker_chromium.org, falken, blink-worker-reviews_chromium.org, horo+watch_chromium.org, yhirano Base URL:
https://chromium.googlesource.com/chromium/src.git@master Target Ref:
refs/pending/heads/master Project:
chromium Visibility:
Public. |
Description[Reland] Worker: Protect a running debugger task from forcible worker termination (2)
Note: The original CL was reverted because another CL that it depends on was
reverted: https://codereview.chromium.org/2046483002/
A running debugger task must be protected from forcible worker termination, but
in the current implementation, there is a corner case where the debugger task
can suddenly be killed as follows:
1) terminate() is called while a debugger task is running. This does not
schedule a task to forcibly terminate the worker execution.
2) terminateAndWait() is called while a debugger task is still running. This
attempts to overtake the scheduled (actually not scheduled) termination task
and forcibly terminates the worker execution.
3) The running debugger task is interrupted and possibly crashes.
After this change, terminateAndWait() respects the running debugger task on the
step 2).
BUG=616775
TBR=kinuko@chromium.org
Committed: https://crrev.com/20d56e4845354062512ee3655e7cf2501400dc7d
Cr-Commit-Position: refs/heads/master@{#400400}
Patch Set 1 : the original CL #Patch Set 2 : pick up a part of code that this CL depends on from https://codereview.chromium.org/2053273002/ #
Messages
Total messages: 17 (11 generated)
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that this CL depends on was reverted. A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ==========
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that this CL depends on was reverted. A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that the original CL depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ==========
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that the original CL depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ==========
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org ==========
nhiroki@chromium.org changed reviewers: + kinuko@chromium.org
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because a CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because another CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org ==========
Let me use TBR because this CL is (almost) the same as the original CL. The original CL was reverted because another CL that it depends on was reverted (https://codereview.chromium.org/2046483002/). I tweaked this CL not to depend on that CL.
The CQ bit was checked by nhiroki@chromium.org
CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/patch-status/2074863002/20001
The CQ bit was unchecked by commit-bot@chromium.org
Try jobs failed on following builders: win_chromium_rel_ng on tryserver.chromium.win (JOB_FAILED, http://build.chromium.org/p/tryserver.chromium.win/builders/win_chromium_rel_...)
The CQ bit was checked by nhiroki@chromium.org
CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/patch-status/2074863002/20001
Message was sent while issue was closed.
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because another CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because another CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org ==========
Message was sent while issue was closed.
Committed patchset #2 (id:20001)
Message was sent while issue was closed.
Description was changed from ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because another CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org ========== to ========== [Reland] Worker: Protect a running debugger task from forcible worker termination (2) Note: The original CL was reverted because another CL that it depends on was reverted: https://codereview.chromium.org/2046483002/ A running debugger task must be protected from forcible worker termination, but in the current implementation, there is a corner case where the debugger task can suddenly be killed as follows: 1) terminate() is called while a debugger task is running. This does not schedule a task to forcibly terminate the worker execution. 2) terminateAndWait() is called while a debugger task is still running. This attempts to overtake the scheduled (actually not scheduled) termination task and forcibly terminates the worker execution. 3) The running debugger task is interrupted and possibly crashes. After this change, terminateAndWait() respects the running debugger task on the step 2). BUG=616775 TBR=kinuko@chromium.org Committed: https://crrev.com/20d56e4845354062512ee3655e7cf2501400dc7d Cr-Commit-Position: refs/heads/master@{#400400} ==========
Message was sent while issue was closed.
Patchset 2 (id:??) landed as https://crrev.com/20d56e4845354062512ee3655e7cf2501400dc7d Cr-Commit-Position: refs/heads/master@{#400400} |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
