mirror of
https://github.com/RGBCube/serenity
synced 2025-10-31 22:02:44 +00:00
dea62fe93c
There are callers of processes().with or processes().for_each that require interrupts to be disabled. Taking a Mutexe with interrupts disabled is a recipe for deadlock, so convert this to a Spinlock.
137 lines
3.3 KiB
C++
137 lines
3.3 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <Kernel/Arch/x86/InterruptDisabler.h>
|
|
#include <Kernel/Process.h>
|
|
|
|
namespace Kernel {
|
|
|
|
KResult Process::do_kill(Process& process, int signal)
|
|
{
|
|
// FIXME: Allow sending SIGCONT to everyone in the process group.
|
|
// FIXME: Should setuid processes have some special treatment here?
|
|
if (!is_superuser() && euid() != process.uid() && uid() != process.uid())
|
|
return EPERM;
|
|
if (process.is_kernel_process()) {
|
|
dbgln("Attempted to send signal {} to kernel process {} ({})", signal, process.name(), process.pid());
|
|
return EPERM;
|
|
}
|
|
if (signal != 0)
|
|
return process.send_signal(signal, this);
|
|
return KSuccess;
|
|
}
|
|
|
|
KResult Process::do_killpg(ProcessGroupID pgrp, int signal)
|
|
{
|
|
InterruptDisabler disabler;
|
|
|
|
VERIFY(pgrp >= 0);
|
|
|
|
// Send the signal to all processes in the given group.
|
|
if (pgrp == 0) {
|
|
// Send the signal to our own pgrp.
|
|
pgrp = pgid();
|
|
}
|
|
|
|
bool group_was_empty = true;
|
|
bool any_succeeded = false;
|
|
KResult error = KSuccess;
|
|
|
|
Process::for_each_in_pgrp(pgrp, [&](auto& process) {
|
|
group_was_empty = false;
|
|
|
|
KResult res = do_kill(process, signal);
|
|
if (res.is_success())
|
|
any_succeeded = true;
|
|
else
|
|
error = res;
|
|
});
|
|
|
|
if (group_was_empty)
|
|
return ESRCH;
|
|
if (any_succeeded)
|
|
return KSuccess;
|
|
return error;
|
|
}
|
|
|
|
KResult Process::do_killall(int signal)
|
|
{
|
|
InterruptDisabler disabler;
|
|
|
|
bool any_succeeded = false;
|
|
KResult error = KSuccess;
|
|
|
|
// Send the signal to all processes we have access to for.
|
|
processes().for_each([&](auto& process) {
|
|
KResult res = KSuccess;
|
|
if (process.pid() == pid())
|
|
res = do_killself(signal);
|
|
else
|
|
res = do_kill(process, signal);
|
|
|
|
if (res.is_success())
|
|
any_succeeded = true;
|
|
else
|
|
error = res;
|
|
});
|
|
|
|
if (any_succeeded)
|
|
return KSuccess;
|
|
return error;
|
|
}
|
|
|
|
KResult Process::do_killself(int signal)
|
|
{
|
|
if (signal == 0)
|
|
return KSuccess;
|
|
|
|
auto current_thread = Thread::current();
|
|
if (!current_thread->should_ignore_signal(signal))
|
|
current_thread->send_signal(signal, this);
|
|
|
|
return KSuccess;
|
|
}
|
|
|
|
KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
|
|
{
|
|
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
|
|
if (pid_or_pgid == pid().value())
|
|
REQUIRE_PROMISE(stdio);
|
|
else
|
|
REQUIRE_PROMISE(proc);
|
|
|
|
if (signal < 0 || signal >= 32)
|
|
return EINVAL;
|
|
if (pid_or_pgid < -1) {
|
|
if (pid_or_pgid == NumericLimits<i32>::min())
|
|
return EINVAL;
|
|
return do_killpg(-pid_or_pgid, signal);
|
|
}
|
|
if (pid_or_pgid == -1)
|
|
return do_killall(signal);
|
|
if (pid_or_pgid == pid().value()) {
|
|
return do_killself(signal);
|
|
}
|
|
VERIFY(pid_or_pgid >= 0);
|
|
auto peer = Process::from_pid(pid_or_pgid);
|
|
if (!peer)
|
|
return ESRCH;
|
|
return do_kill(*peer, signal);
|
|
}
|
|
|
|
KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
|
|
{
|
|
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
|
|
REQUIRE_PROMISE(proc);
|
|
if (signum < 1 || signum >= 32)
|
|
return EINVAL;
|
|
if (pgrp < 0)
|
|
return EINVAL;
|
|
|
|
return do_killpg(pgrp, signum);
|
|
}
|
|
|
|
}
|