blob: c823d9c556a56738f0ef0e53e91ab4e222521edb [file]
// Copyright 2025 The Fuchsia 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 <fcntl.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
#include <thread>
#include <gtest/gtest.h>
#include "src/lib/files/directory.h"
#include "src/lib/files/file.h"
#include "src/lib/fxl/strings/string_printf.h"
#include "src/starnix/tests/syscalls/cpp/proc_test_base.h"
#include "src/starnix/tests/syscalls/cpp/syscall_matchers.h"
#include "src/starnix/tests/syscalls/cpp/test_helper.h"
namespace {
std::string ProcFilePath(pid_t pid, const char* name) {
return fxl::StringPrintf("/proc/%d/%s", pid, name);
}
class ZombieProcTest : public ProcTestBase {
protected:
void SetUp() override {
ProcTestBase::SetUp();
SpawnZombie();
}
void TearDown() override {
ReapZombie();
ProcTestBase::TearDown();
}
void SpawnZombie() {
test_helper::Rendezvous ready = test_helper::MakeRendezvous();
test_helper::Rendezvous complete = test_helper::MakeRendezvous();
leader_pid_ = fork_helper_.RunInForkedProcess(
[ready = std::move(ready.poker), complete = std::move(complete.holder)]() mutable {
// Spawn a control thread. This thread will block until the test signals that it is done
// inspecting the zombie task. At that point, the control thread will exit, causing the
// entire forked thread group to exit.
std::thread([&] { complete.hold(); }).detach();
// Signal to the test that the leader is entering the zombie state. Then, exit the leader
// thread while the control thread blocks, keeping the forked thread group alive.
ready.poke();
syscall(SYS_exit, 0);
});
// Wait for the leader thread to exit, entering the zombie state.
complete_ = std::move(complete.poker);
ready.holder.hold();
ASSERT_TRUE(test_helper::WaitUntilZombie(leader_pid_));
}
void ReapZombie() {
// Signal for the forked thread group to exit.
complete_.poke();
ASSERT_TRUE(fork_helper_.WaitForChildren());
}
bool ReadZombieProcFile(const char* name, std::string& contents) const {
std::string path = ProcFilePath(leader_pid_, name);
return files::ReadFileToString(path, &contents);
}
testing::AssertionResult AssertZombieProcFileOpenError(const char* name,
int expected_errno) const {
std::string path = ProcFilePath(leader_pid_, name);
fbl::unique_fd fd(open(path.c_str(), O_RDONLY));
// Being able to open the file is an error. For debugging purposes, log the contents of the file
// if it can be opened.
if (fd) {
std::string contents;
if (files::ReadFileDescriptorToString(fd.get(), &contents)) {
return testing::AssertionFailure()
<< "Opening " << path
<< " succeeded, expected failure, but got contents: " << contents;
}
return testing::AssertionFailure()
<< "Opening " << path << " succeeded, expected failure, but could not read contents";
}
if (errno != expected_errno) {
return testing::AssertionFailure() << "Expected open(" << path << ") to fail with "
<< expected_errno << ", but got " << errno;
}
return testing::AssertionSuccess();
}
testing::AssertionResult AssertZombieProcFileReadError(const char* name,
int expected_errno) const {
std::string path = ProcFilePath(leader_pid_, name);
fbl::unique_fd fd(open(path.c_str(), O_RDONLY));
if (!fd) {
return testing::AssertionFailure() << "Failed to open " << path << ": " << errno;
}
char buf[1];
ssize_t res = read(fd.get(), buf, sizeof(buf));
if (res >= 0) {
return testing::AssertionFailure() << "Read from " << path << " succeeded, expected failure";
}
if (errno != expected_errno) {
return testing::AssertionFailure() << "Expected read(" << path << ") to fail with "
<< expected_errno << ", but got " << errno;
}
return testing::AssertionSuccess();
}
testing::AssertionResult AssertZombieProcFileEmpty(const char* name) const {
std::string contents;
if (!ReadZombieProcFile(name, contents)) {
return testing::AssertionFailure() << "Failed to read file " << name;
}
if (!contents.empty()) {
return testing::AssertionFailure()
<< "Expected file " << name << " to be empty, but got contents: " << contents;
}
return testing::AssertionSuccess();
}
testing::AssertionResult AssertZombieProcFileNotEmpty(const char* name) const {
std::string contents;
if (!ReadZombieProcFile(name, contents)) {
return testing::AssertionFailure() << "Failed to read file " << name;
}
if (contents.empty()) {
return testing::AssertionFailure() << "Expected file " << name << " to be non-empty";
}
return testing::AssertionSuccess();
}
testing::AssertionResult AssertZombieProcDirEmpty(const char* name) const {
std::string path = ProcFilePath(leader_pid_, name);
std::vector<std::string> contents;
if (!files::ReadDirContents(path, &contents)) {
return testing::AssertionFailure() << "Failed to read directory " << path;
}
const std::vector<std::string> empty_contents = {".", ".."};
if (contents != empty_contents) {
return testing::AssertionFailure() << "Expected directory " << path << " to be empty";
}
return testing::AssertionSuccess();
}
testing::AssertionResult AssertZombieProcDirNotEmpty(const char* name) const {
std::string path = ProcFilePath(leader_pid_, name);
std::vector<std::string> contents;
if (!files::ReadDirContents(path, &contents)) {
return testing::AssertionFailure() << "Failed to read directory " << path;
}
std::vector<std::string> empty_contents = {".", ".."};
if (contents == empty_contents) {
return testing::AssertionFailure() << "Expected directory " << path << " to be non-empty";
}
return testing::AssertionSuccess();
}
test_helper::ForkHelper fork_helper_;
test_helper::Poker complete_;
pid_t leader_pid_;
};
// Nodes that fail with ENOENT on open()
TEST_F(ZombieProcTest, Cwd) { ASSERT_TRUE(AssertZombieProcFileOpenError("cwd", ENOENT)); }
TEST_F(ZombieProcTest, Exe) { ASSERT_TRUE(AssertZombieProcFileOpenError("exe", ENOENT)); }
TEST_F(ZombieProcTest, Root) { ASSERT_TRUE(AssertZombieProcFileOpenError("root", ENOENT)); }
// Nodes that fail with EINVAL on open()
TEST_F(ZombieProcTest, MountInfo) {
ASSERT_TRUE(AssertZombieProcFileOpenError("mountinfo", EINVAL));
}
TEST_F(ZombieProcTest, Mounts) { ASSERT_TRUE(AssertZombieProcFileOpenError("mounts", EINVAL)); }
// Nodes that succeed on open() but fail with ESRCH on read()
// Linux 6.6 allows open() without an mm and fails on read() with ESRCH (Linux 6.11+ fails on
// open()).
TEST_F(ZombieProcTest, SmapsRollup) {
ASSERT_TRUE(AssertZombieProcFileReadError("smaps_rollup", ESRCH));
}
// Nodes that succeed on open() but fail with EINVAL on read()
TEST_F(ZombieProcTest, AttrExec) {
ASSERT_TRUE(AssertZombieProcFileReadError("attr/exec", EINVAL));
}
TEST_F(ZombieProcTest, AttrFscreate) {
ASSERT_TRUE(AssertZombieProcFileReadError("attr/fscreate", EINVAL));
}
TEST_F(ZombieProcTest, AttrKeycreate) {
ASSERT_TRUE(AssertZombieProcFileReadError("attr/keycreate", EINVAL));
}
TEST_F(ZombieProcTest, AttrPrev) {
ASSERT_TRUE(AssertZombieProcFileReadError("attr/prev", EINVAL));
}
TEST_F(ZombieProcTest, AttrSockcreate) {
ASSERT_TRUE(AssertZombieProcFileReadError("attr/sockcreate", EINVAL));
}
TEST_F(ZombieProcTest, ClearRefs) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileReadError("clear_refs", EINVAL));
}
// Nodes that are readable and contain no data
TEST_F(ZombieProcTest, Auxv) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileEmpty("auxv"));
}
TEST_F(ZombieProcTest, Cmdline) { ASSERT_TRUE(AssertZombieProcFileEmpty("cmdline")); }
TEST_F(ZombieProcTest, Environ) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileEmpty("environ"));
}
TEST_F(ZombieProcTest, Fd) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcDirEmpty("fd"));
}
TEST_F(ZombieProcTest, FdInfo) { ASSERT_TRUE(AssertZombieProcDirEmpty("fdinfo")); }
TEST_F(ZombieProcTest, Maps) { ASSERT_TRUE(AssertZombieProcFileEmpty("maps")); }
TEST_F(ZombieProcTest, Mem) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileEmpty("mem"));
}
TEST_F(ZombieProcTest, PageMap) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileEmpty("pagemap"));
}
TEST_F(ZombieProcTest, Smaps) { ASSERT_TRUE(AssertZombieProcFileEmpty("smaps")); }
// Nodes that are readable and contain general data
TEST_F(ZombieProcTest, AttrCurrent) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("attr/current")); }
TEST_F(ZombieProcTest, Cgroup) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("cgroup")); }
TEST_F(ZombieProcTest, Comm) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("comm")); }
TEST_F(ZombieProcTest, Io) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileNotEmpty("io"));
}
TEST_F(ZombieProcTest, Limits) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("limits")); }
TEST_F(ZombieProcTest, Ns) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcDirNotEmpty("ns"));
}
TEST_F(ZombieProcTest, OomAdj) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("oom_adj")); }
TEST_F(ZombieProcTest, OomScore) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("oom_score")); }
TEST_F(ZombieProcTest, OomScoreAdj) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("oom_score_adj")); }
TEST_F(ZombieProcTest, Sched) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("sched")); }
TEST_F(ZombieProcTest, Schedstat) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("schedstat")); }
TEST_F(ZombieProcTest, Statm) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("statm")); }
TEST_F(ZombieProcTest, TimerslackNs) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Requires CAP_SYS_ADMIN";
}
ASSERT_TRUE(AssertZombieProcFileNotEmpty("timerslack_ns"));
}
TEST_F(ZombieProcTest, Wchan) { ASSERT_TRUE(AssertZombieProcFileNotEmpty("wchan")); }
// Nodes that are readable and contain specific data
TEST_F(ZombieProcTest, Stat) {
std::string stat;
ASSERT_TRUE(ReadZombieProcFile("stat", stat));
char state;
ASSERT_EQ(sscanf(stat.c_str(), "%*d %*s %c", &state), 1) << stat;
ASSERT_EQ(state, 'Z');
}
TEST_F(ZombieProcTest, Status) {
std::string status;
ASSERT_TRUE(ReadZombieProcFile("status", status));
ASSERT_THAT(status, testing::ContainsRegex("\nState:[[:space:]]+Z \\(zombie\\)\n"));
}
TEST(ZombieTest, Setpgid) {
test_helper::ForkHelper fork_helper;
fork_helper.OnlyWaitForForkedChildren();
fork_helper.ExpectExitValue(42);
pid_t child_pid = fork_helper.RunInForkedProcess([] { _exit(42); });
ASSERT_TRUE(test_helper::WaitUntilZombie(child_pid));
ASSERT_THAT(setpgid(child_pid, child_pid), SyscallSucceeds());
EXPECT_THAT(getpgid(child_pid), SyscallSucceedsWithValue(child_pid));
int status = 0;
EXPECT_THAT(waitpid(0, &status, WNOHANG), SyscallFailsWithErrno(ECHILD));
EXPECT_THAT(waitpid(-child_pid, &status, 0), SyscallSucceedsWithValue(child_pid));
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(WEXITSTATUS(status), 42);
EXPECT_THAT(waitpid(child_pid, &status, WNOHANG), SyscallFailsWithErrno(ECHILD));
}
} // namespace