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
|
// Copyright 2015 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <brillo/process_reaper.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>
#include <base/bind.h>
#include <base/location.h>
#include <base/message_loop/message_loop.h>
#include <brillo/asynchronous_signal_handler.h>
#include <brillo/bind_lambda.h>
#include <brillo/message_loops/base_message_loop.h>
#include <gtest/gtest.h>
namespace {
pid_t ForkChildAndExit(int exit_code) {
pid_t pid = fork();
PCHECK(pid != -1);
if (pid == 0) {
_exit(exit_code);
}
return pid;
}
pid_t ForkChildAndKill(int sig) {
pid_t pid = fork();
PCHECK(pid != -1);
if (pid == 0) {
if (raise(sig) != 0) {
PLOG(ERROR) << "raise(" << sig << ")";
}
_exit(0); // Not reached. This value will cause the test to fail.
}
return pid;
}
} // namespace
namespace brillo {
class ProcessReaperTest : public ::testing::Test {
public:
void SetUp() override {
brillo_loop_.SetAsCurrent();
async_signal_handler_.Init();
process_reaper_.Register(&async_signal_handler_);
}
protected:
base::MessageLoopForIO base_loop_;
brillo::BaseMessageLoop brillo_loop_{&base_loop_};
brillo::AsynchronousSignalHandler async_signal_handler_;
// ProcessReaper under test.
ProcessReaper process_reaper_;
};
TEST_F(ProcessReaperTest, UnregisterWhenNotRegistered) {
ProcessReaper another_process_reaper_;
another_process_reaper_.Unregister();
}
TEST_F(ProcessReaperTest, UnregisterAndReregister) {
process_reaper_.Unregister();
process_reaper_.Register(&async_signal_handler_);
// This checks that we can unregister the ProcessReaper and then destroy it.
process_reaper_.Unregister();
}
TEST_F(ProcessReaperTest, ReapExitedChild) {
pid_t pid = ForkChildAndExit(123);
EXPECT_TRUE(process_reaper_.WatchForChild(FROM_HERE, pid, base::Bind(
[](MessageLoop* loop, const siginfo_t& info) {
EXPECT_EQ(CLD_EXITED, info.si_code);
EXPECT_EQ(123, info.si_status);
loop->BreakLoop();
}, &brillo_loop_)));
brillo_loop_.Run();
}
// Test that simultaneous child processes fire their respective callbacks when
// exiting.
TEST_F(ProcessReaperTest, ReapedChildrenMatchCallbacks) {
int running_children = 10;
for (int i = 0; i < running_children; ++i) {
// Different processes will have different exit values.
int exit_value = 1 + i;
pid_t pid = ForkChildAndExit(exit_value);
EXPECT_TRUE(process_reaper_.WatchForChild(FROM_HERE, pid, base::Bind(
[](MessageLoop* loop, int exit_value, int* running_children,
const siginfo_t& info) {
EXPECT_EQ(CLD_EXITED, info.si_code);
EXPECT_EQ(exit_value, info.si_status);
(*running_children)--;
if (*running_children == 0)
loop->BreakLoop();
}, &brillo_loop_, exit_value, &running_children)));
}
// This sleep is optional. It helps to have more processes exit before we
// start watching for them in the message loop.
usleep(10 * 1000);
brillo_loop_.Run();
EXPECT_EQ(0, running_children);
}
TEST_F(ProcessReaperTest, ReapKilledChild) {
pid_t pid = ForkChildAndKill(SIGKILL);
EXPECT_TRUE(process_reaper_.WatchForChild(FROM_HERE, pid, base::Bind(
[](MessageLoop* loop, const siginfo_t& info) {
EXPECT_EQ(CLD_KILLED, info.si_code);
EXPECT_EQ(SIGKILL, info.si_status);
loop->BreakLoop();
}, &brillo_loop_)));
brillo_loop_.Run();
}
TEST_F(ProcessReaperTest, ReapKilledAndForgottenChild) {
pid_t pid = ForkChildAndExit(0);
EXPECT_TRUE(process_reaper_.WatchForChild(FROM_HERE, pid, base::Bind(
[](MessageLoop* loop, const siginfo_t& /* info */) {
ADD_FAILURE() << "Child process was still tracked.";
loop->BreakLoop();
}, &brillo_loop_)));
EXPECT_TRUE(process_reaper_.ForgetChild(pid));
// A second call should return failure.
EXPECT_FALSE(process_reaper_.ForgetChild(pid));
// Run the loop with a timeout, as the BreakLoop() above is not expected.
brillo_loop_.PostDelayedTask(FROM_HERE,
base::Bind(&MessageLoop::BreakLoop,
base::Unretained(&brillo_loop_)),
base::TimeDelta::FromMilliseconds(100));
brillo_loop_.Run();
}
} // namespace brillo
|
