beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Kernel: Ignore subsequent calls to Process::die

Browse source 
It's possible that another thread might try to exit the process just
about the same time another thread does the same, or a crash happens.
Also, we may not be able to kill all other threads instantly as they
may be blocked in the kernel (though in this case they would get killed
before ever returning back to user mode. So keep track of whether
Process::die was already called and ignore it on subsequent calls.

Fixes #8485
This commit is contained in:
Tom 2021-07-13 17:15:24 -06:00 committed by Andreas Kling
parent 3cc0283eac
commit d7e5521a04
Notes: sideshowbarker 2024-07-18 09:05:20 +09:00 
Author: https://github.com/tomuta
Commit: https://github.com/SerenityOS/serenity/commit/d7e5521a042
Pull-request: https://github.com/SerenityOS/serenity/pull/8735
Issue: https://github.com/SerenityOS/serenity/issues/8485
Reviewed-by: https://github.com/ADKaster
3 changed files with 25 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
Kernel/Process.cpp
View file

@ -581,7 +581,7 @@ void Process::finalize()
// allow us to take references anymore.
ProcFSComponentRegistry::the().unregister_process(*this);
m_dead = true;
m_state.store(State::Dead, AK::MemoryOrder::memory_order_release);
{
// FIXME: PID/TID BUG
@ -626,6 +626,15 @@ void Process::unblock_waiters(Thread::WaitBlocker::UnblockFlags flags, u8 signal
void Process::die()
{
auto expected = State::Running;
if (!m_state.compare_exchange_strong(expected, State::Dying, AK::memory_order_acquire)) {
// It's possible that another thread calls this at almost the same time
// as we can't always instantly kill other threads (they may be blocked)
// So if we already were called then other threads should stop running
// momentarily and we only really need to service the first thread
return;
}
// Let go of the TTY, otherwise a slave PTY may keep the master PTY from
// getting an EOF when the last process using the slave PTY dies.
// If the master PTY owner relies on an EOF to know when to wait() on a

11
Kernel/Process.h
View file

@ -148,6 +148,12 @@ class Process
Process& m_process;
};
enum class State : u8 {
Running = 0,
Dying,
Dead
};
public:
inline static Process* current()
{
@ -201,7 +207,8 @@ public:
bool should_core_dump() const { return m_should_dump_core; }
void set_dump_core(bool dump_core) { m_should_dump_core = dump_core; }
bool is_dead() const { return m_dead; }
bool is_dying() const { return m_state.load(AK::MemoryOrder::memory_order_acquire) != State::Running; }
bool is_dead() const { return m_state.load(AK::MemoryOrder::memory_order_acquire) == State::Dead; }
bool is_stopped() const { return m_is_stopped; }
bool set_stopped(bool stopped) { return m_is_stopped.exchange(stopped); }
@ -670,7 +677,7 @@ private:
mutable RecursiveSpinLock m_thread_list_lock;
const bool m_is_kernel_process;
bool m_dead { false };
Atomic<State> m_state { State::Running };
bool m_profiling { false };
Atomic<bool, AK::MemoryOrder::memory_order_relaxed> m_is_stopped { false };
bool m_should_dump_core { false };

6
Kernel/Syscall.cpp
View file

@ -155,6 +155,12 @@ NEVER_INLINE void syscall_handler(TrapFrame* trap)
auto current_thread = Thread::current();
VERIFY(current_thread->previous_mode() == Thread::PreviousMode::UserMode);
auto& process = current_thread->process();
if (process.is_dying()) {
// It's possible this thread is just about to make a syscall while another is
// is killing our process.
current_thread->die_if_needed();
return;
}
if (auto tracer = process.tracer(); tracer && tracer->is_tracing_syscalls()) {
tracer->set_trace_syscalls(false);