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
|
// Copyright 2024 syzkaller project authors. All rights reserved.
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
#include <spawn.h>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>
// Subprocess allows to start and wait for a subprocess.
class Subprocess
{
public:
Subprocess(const char** argv, const std::vector<std::pair<int, int>>& fds)
{
posix_spawn_file_actions_t actions;
if (posix_spawn_file_actions_init(&actions))
fail("posix_spawn_file_actions_init failed");
int max_fd = 0;
for (auto pair : fds)
max_fd = std::max(max_fd, pair.second);
for (auto pair : fds) {
if (pair.first != -1) {
// Remapping won't work if fd's overlap with the target range:
// we can dup something onto fd we need to dup later, in such case the later fd
// will be wrong. Resolving this would require some tricky multi-pass remapping.
// So we just require the caller to not do that.
if (pair.first <= max_fd)
failmsg("bad subprocess fd", "%d->%d max_fd=%d",
pair.first, pair.second, max_fd);
if (posix_spawn_file_actions_adddup2(&actions, pair.first, pair.second))
fail("posix_spawn_file_actions_adddup2 failed");
} else {
if (posix_spawn_file_actions_addclose(&actions, pair.second))
fail("posix_spawn_file_actions_addclose failed");
}
}
for (int i = max_fd + 1; i < kFdLimit; i++) {
if (posix_spawn_file_actions_addclose(&actions, i))
fail("posix_spawn_file_actions_addclose failed");
}
posix_spawnattr_t attr;
if (posix_spawnattr_init(&attr))
fail("posix_spawnattr_init failed");
// Create new process group so that we can kill all processes in the group.
if (posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETPGROUP))
fail("posix_spawnattr_setflags failed");
const char* child_envp[] = {
// Tell ASAN to not mess with our NONFAILING and disable leak checking
// (somehow lsan is very slow in syzbot arm64 image and we are not very interested
// in leaks in the exec subprocess, it does not use malloc/new anyway).
"ASAN_OPTIONS=handle_segv=0 allow_user_segv_handler=1 detect_leaks=0",
// Disable rseq since we don't use it and we want to [ab]use it ourselves for kernel testing.
"GLIBC_TUNABLES=glibc.pthread.rseq=0",
nullptr};
if (posix_spawnp(&pid_, argv[0], &actions, &attr,
const_cast<char**>(argv), const_cast<char**>(child_envp)))
fail("posix_spawnp failed");
if (posix_spawn_file_actions_destroy(&actions))
fail("posix_spawn_file_actions_destroy failed");
if (posix_spawnattr_destroy(&attr))
fail("posix_spawnattr_destroy failed");
}
~Subprocess()
{
if (pid_)
KillAndWait();
}
int KillAndWait()
{
if (!pid_)
fail("subprocess hasn't started or already waited");
kill(pid_, SIGKILL);
int pid = 0;
int wstatus = 0;
do
pid = waitpid(pid_, &wstatus, WAIT_FLAGS);
while (pid == -1 && errno == EINTR);
if (pid != pid_)
failmsg("child wait failed", "pid_=%d pid=%d", pid_, pid);
if (WIFSTOPPED(wstatus))
failmsg("child stopped", "status=%d", wstatus);
pid_ = 0;
return ExitStatus(wstatus);
}
int WaitAndKill(uint64 timeout_ms)
{
if (!pid_)
fail("subprocess hasn't started or already waited");
uint64 start = current_time_ms();
int wstatus = 0;
for (;;) {
sleep_ms(10);
if (waitpid(pid_, &wstatus, WNOHANG | WAIT_FLAGS) == pid_)
break;
if (current_time_ms() - start > timeout_ms) {
kill(-pid_, SIGKILL);
kill(pid_, SIGKILL);
}
}
pid_ = 0;
return ExitStatus(wstatus);
}
private:
int pid_ = 0;
static int ExitStatus(int wstatus)
{
if (WIFEXITED(wstatus))
return WEXITSTATUS(wstatus);
if (WIFSIGNALED(wstatus)) {
// Map signal numbers to some reasonable exit statuses.
// We only log them and compare to kFailStatus, so ensure it's not kFailStatus
// and not 0, otherwise return the signal as is (e.g. exit status 11 is SIGSEGV).
switch (WTERMSIG(wstatus)) {
case kFailStatus:
return kFailStatus - 1;
case 0:
return kFailStatus - 2;
default:
return WTERMSIG(wstatus);
}
}
// This may be possible in WIFSTOPPED case for C programs.
return kFailStatus - 3;
}
Subprocess(const Subprocess&) = delete;
Subprocess& operator=(const Subprocess&) = delete;
};
|
