bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Properly abort when thread result panics on drop.

Browse source
This commit is contained in:
Mara Bos 2022-03-05 18:07:20 +01:00
parent 5226395d6f
commit 7a481ff8a4
2 changed files with 26 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

40
library/std/src/thread/mod.rs
View file

@ -1287,29 +1287,31 @@ unsafe impl<'scope, T: Sync> Sync for Packet<'scope, T> {}
impl<'scope, T> Drop for Packet<'scope, T> {
fn drop(&mut self) {
// If this packet was for a thread that ran in a scope, the thread
// panicked, and nobody consumed the panic payload, we make sure
// the scope function will panic.
let unhandled_panic = matches!(self.result.get_mut(), Some(Err(_)));
// Drop the result without causing unwinding.
// This is only relevant for threads that aren't join()ed, as
// join() will take the `result` and set it to None, such that
// there is nothing left to drop here.
// If this panics, we should handle that, because we're outside the
// outermost `catch_unwind` of our thread.
// We just abort in that case, since there's nothing else we can do.
// (And even if we tried to handle it somehow, we'd also need to handle
// the case where the panic payload we get out of it also panics on
// drop, and so on. See issue #86027.)
if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| {
*self.result.get_mut() = None;
})) {
rtabort!("thread result panicked on drop");
}
// Book-keeping so the scope knows when it's done.
if let Some(scope) = self.scope {
// If this packet was for a thread that ran in a scope, the thread
// panicked, and nobody consumed the panic payload, we make sure
// the scope function will panic.
let unhandled_panic = matches!(self.result.get_mut(), Some(Err(_)));
// Drop the result before decrementing the number of running
// threads, because the Drop implementation might still use things
// it borrowed from 'scope.
// This is only relevant for threads that aren't join()ed, as
// join() will take the `result` and set it to None, such that
// there is nothing left to drop here.
// If this drop panics, that just results in an abort, because
// we're outside of the outermost `catch_unwind` of our thread.
// The same happens for detached non-scoped threads when dropping
// their ignored return value (or panic payload) panics, so
// there's no need to try to do anything better.
// (And even if we tried to handle it, we'd also need to handle
// the case where the panic payload we get out of it also panics
// on drop, and so on. See issue #86027.)
*self.result.get_mut() = None;
// Now that there will be no more user code running on this thread
// that can use 'scope, mark the thread as 'finished'.
// It's important we only do this after the `result` has been dropped,
// since dropping it might still use things it borrowed from 'scope.
scope.decrement_num_running_threads(unhandled_panic);
}
}