1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/Process.h>
namespace Kernel {
ErrorOr<void> Process::do_kill(Process& process, int signal)
{
// FIXME: Should setuid processes have some special treatment here?
auto credentials = this->credentials();
auto kill_process_credentials = process.credentials();
bool can_send_signal = credentials->is_superuser()
|| credentials->euid() == kill_process_credentials->uid()
|| credentials->uid() == kill_process_credentials->uid()
|| (signal == SIGCONT && credentials->pgid() == kill_process_credentials->pgid());
if (!can_send_signal)
return EPERM;
if (process.is_kernel_process()) {
process.name().with([&](auto& process_name) {
dbgln("Attempted to send signal {} to kernel process {} ({})", signal, process_name->view(), process.pid());
});
return EPERM;
}
if (signal != 0)
return process.send_signal(signal, this);
return {};
}
ErrorOr<void> Process::do_killpg(ProcessGroupID pgrp, int signal)
{
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;
ErrorOr<void> error;
TRY(Process::current().for_each_in_pgrp_in_same_jail(pgrp, [&](auto& process) -> ErrorOr<void> {
group_was_empty = false;
ErrorOr<void> res = do_kill(process, signal);
if (!res.is_error())
any_succeeded = true;
else
error = move(res);
return {};
}));
if (group_was_empty)
return ESRCH;
if (any_succeeded)
return {};
return error;
}
ErrorOr<void> Process::do_killall(int signal)
{
bool any_succeeded = false;
ErrorOr<void> error;
// Send the signal to all processes we have access to for.
TRY(Process::for_each_in_same_jail([&](auto& process) -> ErrorOr<void> {
ErrorOr<void> res;
if (process.pid() == pid())
res = do_killself(signal);
else
res = do_kill(process, signal);
if (!res.is_error())
any_succeeded = true;
else
error = move(res);
return {};
}));
if (any_succeeded)
return {};
return error;
}
ErrorOr<void> Process::do_killself(int signal)
{
if (signal == 0)
return {};
auto* current_thread = Thread::current();
if (!current_thread->should_ignore_signal(signal))
current_thread->send_signal(signal, this);
return {};
}
ErrorOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
if (pid_or_pgid == pid().value())
TRY(require_promise(Pledge::stdio));
else
TRY(require_promise(Pledge::proc));
if (signal < 0 || signal >= 32)
return EINVAL;
if (pid_or_pgid < -1) {
if (pid_or_pgid == NumericLimits<i32>::min())
return EINVAL;
TRY(do_killpg(-pid_or_pgid, signal));
return 0;
}
if (pid_or_pgid == -1) {
TRY(do_killall(signal));
return 0;
}
if (pid_or_pgid == pid().value()) {
TRY(do_killself(signal));
return 0;
}
VERIFY(pid_or_pgid >= 0);
auto peer = Process::from_pid_in_same_jail(pid_or_pgid);
if (!peer)
return ESRCH;
TRY(do_kill(*peer, signal));
return 0;
}
ErrorOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
TRY(require_promise(Pledge::proc));
if (signum < 1 || signum >= 32)
return EINVAL;
if (pgrp < 0)
return EINVAL;
TRY(do_killpg(pgrp, signum));
return 0;
}
}
|
