src/starnix/tests/syscalls/cpp/cgroup_freezer_test.cc

// Copyright 2024 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 <signal.h>
#include <sys/mount.h>
#include <sys/wait.h>

#include <deque>
#include <filesystem>
#include <fstream>
#include <string>

#include <gtest/gtest.h>

#include "src/lib/files/file.h"
#include "src/starnix/tests/syscalls/cpp/syscall_matchers.h"
#include "src/starnix/tests/syscalls/cpp/test_helper.h"

namespace {

constexpr char PROCS_FILE[] = "cgroup.procs";
constexpr char FREEZE_FILE[] = "cgroup.freeze";
constexpr char EVENTS_FILE[] = "cgroup.events";

std::string procs_path(const std::string& cgroup_path) { return cgroup_path + "/" + PROCS_FILE; }
std::string freeze_path(const std::string& cgroup_path) { return cgroup_path + "/" + FREEZE_FILE; }
std::string events_path(const std::string& cgroup_path) { return cgroup_path + "/" + EVENTS_FILE; }

bool IsCgroupFrozen(const std::string& cgroup_path) {
  std::ifstream events_file(events_path(cgroup_path));
  if (!events_file.is_open()) {
    return false;
  }

  std::string line;
  while (std::getline(events_file, line)) {
    if (line.starts_with("frozen ")) {
      return !!std::atoi(line.substr(7).c_str());
    }
  }
  return false;
}

bool IsCgroupSelfFrozen(const std::string& cgroup_path) {
  std::string freeze_str;
  EXPECT_TRUE(files::ReadFileToString(freeze_path(cgroup_path), &freeze_str));
  return freeze_str == "1\n";
}

void FreezeCgroup(const std::string& cgroup_path) {
  ASSERT_TRUE(files::WriteFile(freeze_path(cgroup_path), "1"));
}

void ThawCgroup(const std::string& cgroup_path) {
  ASSERT_TRUE(files::WriteFile(freeze_path(cgroup_path), "0"));
}

void AddProcToCgroup(pid_t pid, const std::string& cgroup_path) {
  ASSERT_TRUE(files::WriteFile(procs_path(cgroup_path), std::to_string(pid)));
}

void ChildWaitSignal(int signal, int times, pid_t parent_pid) {
  // Set up a signal set to wait for `signal` which will be sent by the parent process
  test_helper::SignalMaskHelper mask_helper;
  mask_helper.blockSignal(signal);

  for (int i = 0; i < times; i++) {
    mask_helper.waitForSignal(signal);
    kill(parent_pid, signal);
  }
}

}  // namespace
class CgroupFreezerTest : public ::testing::Test {
 public:
  void SetUp() override {
    if (!test_helper::HasSysAdmin()) {
      // From https://docs.kernel.org/admin-guide/cgroup-v2.html#interaction-with-other-namespaces
      // mounting cgroup requires CAP_SYS_ADMIN.
      GTEST_SKIP() << "requires CAP_SYS_ADMIN to mount cgroup";
    }
    CreateTestCgroup();
  }

  void TearDown() override { RemoveTestCgroup(); }

 protected:
  std::vector<int> test_pids_;

  void CreateChildCgroup(const std::string& child_path) {
    ASSERT_TRUE(std::filesystem::create_directories(child_path));
    cgroups_.push_front(child_path);
  }

  std::string root_cgroup_path() { return temp_dir_.path() + "/cgroup"; }
  std::string test_cgroup_path() { return root_cgroup_path() + "/test"; }

 private:
  void CreateTestCgroup() {
    ASSERT_FALSE(std::filesystem::exists(root_cgroup_path()));
    ASSERT_TRUE(std::filesystem::create_directories(root_cgroup_path()));
    ASSERT_THAT(mount(nullptr, root_cgroup_path().c_str(), "cgroup2", 0, nullptr),
                SyscallSucceeds());
    ASSERT_TRUE(std::filesystem::create_directories(test_cgroup_path()));
    cgroups_.push_front(test_cgroup_path());
  }

  void RemoveTestCgroup() {
    // Kill the child processes
    for (int pid : test_pids_) {
      kill(pid, SIGKILL);
      waitpid(pid, nullptr, 0);
    }
    for (const auto& cgroup : cgroups_) {
      if (std::filesystem::exists(cgroup)) {
        ASSERT_TRUE(std::filesystem::remove(cgroup));
      }
    }
    if (std::filesystem::exists(root_cgroup_path())) {
      if (test_helper::HasSysAdmin()) {
        ASSERT_THAT(umount(root_cgroup_path().c_str()), SyscallSucceeds());
      }
      ASSERT_TRUE(std::filesystem::remove(root_cgroup_path()));
    }
  }

  test_helper::ScopedTempDir temp_dir_;
  std::deque<std::string> cgroups_;
};

TEST_F(CgroupFreezerTest, FreezeFileAccess) {
  EXPECT_FALSE(IsCgroupSelfFrozen(test_cgroup_path()));
  FreezeCgroup(test_cgroup_path());
  EXPECT_TRUE(IsCgroupSelfFrozen(test_cgroup_path()));
  ThawCgroup(test_cgroup_path());
  EXPECT_FALSE(IsCgroupSelfFrozen(test_cgroup_path()));
}

TEST_F(CgroupFreezerTest, FreezeSingleProcess) {
  pid_t parent_pid = getpid();
  test_helper::ForkHelper fork_helper;

  // Set up a signal set to wait for SIGUSR1 which will be sent by the child process
  test_helper::SignalMaskHelper mask_helper;
  mask_helper.blockSignal(SIGUSR1);

  pid_t child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR1, 2, parent_pid); });
  test_pids_.push_back(child_pid);

  AddProcToCgroup(child_pid, test_cgroup_path());

  // Send signal; child should receive it.
  kill(child_pid, SIGUSR1);
  mask_helper.waitForSignal(SIGUSR1);

  FreezeCgroup(test_cgroup_path());

  // Send signal; frozen child should *not* receive it.
  kill(child_pid, SIGUSR1);
  EXPECT_THAT(mask_helper.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));

  ThawCgroup(test_cgroup_path());

  // Child will process the last signal after thawed.
  mask_helper.waitForSignal(SIGUSR1);

  // Wait for the child process to terminate
  EXPECT_TRUE(fork_helper.WaitForChildren());
}

TEST_F(CgroupFreezerTest, SIGKILLAfterFrozen) {
  pid_t parent_pid = getpid();
  test_helper::ForkHelper fork_helper;

  // Set up a signal set to wait for SIGUSR1 which will be sent by the child process
  test_helper::SignalMaskHelper mask_helper;
  mask_helper.blockSignal(SIGUSR1);

  pid_t child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR1, 2, parent_pid); });
  test_pids_.push_back(child_pid);

  // Make sure the child starts running.
  kill(child_pid, SIGUSR1);
  mask_helper.waitForSignal(SIGUSR1);

  AddProcToCgroup(child_pid, test_cgroup_path());
  FreezeCgroup(test_cgroup_path());

  // Send signal; frozen child should *not* receive it.
  kill(child_pid, SIGUSR1);
  EXPECT_THAT(mask_helper.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));

  // Kill the child process without thawing
  EXPECT_EQ(0, kill(child_pid, SIGKILL));
  EXPECT_FALSE(fork_helper.WaitForChildren());
}

TEST_F(CgroupFreezerTest, AddProcAfterFrozen) {
  pid_t parent_pid = getpid();
  test_helper::ForkHelper fork_helper;

  // Set up a signal set to wait for SIGUSR1 which will be sent by the child process
  test_helper::SignalMaskHelper mask_helper;
  mask_helper.blockSignal(SIGUSR1);

  FreezeCgroup(test_cgroup_path());

  pid_t child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR1, 2, parent_pid); });
  test_pids_.push_back(child_pid);

  // Make sure the child starts running.
  kill(child_pid, SIGUSR1);
  mask_helper.waitForSignal(SIGUSR1);

  AddProcToCgroup(child_pid, test_cgroup_path());

  // Send signal; frozen child should *not* receive it.
  kill(child_pid, SIGUSR1);
  EXPECT_THAT(mask_helper.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));

  ThawCgroup(test_cgroup_path());

  // Child will process the last signal after thawed.
  mask_helper.waitForSignal(SIGUSR1);

  // Wait for the child process to terminate
  EXPECT_TRUE(fork_helper.WaitForChildren());
}

TEST_F(CgroupFreezerTest, AddProcAfterThawed) {
  pid_t parent_pid = getpid();
  test_helper::ForkHelper fork_helper;

  // Set up a signal set to wait for SIGUSR1 which will be sent by the child process
  test_helper::SignalMaskHelper mask_helper;
  mask_helper.blockSignal(SIGUSR1);

  FreezeCgroup(test_cgroup_path());
  ThawCgroup(test_cgroup_path());

  pid_t child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR1, 1, parent_pid); });
  test_pids_.push_back(child_pid);

  AddProcToCgroup(child_pid, test_cgroup_path());

  // Send signal; child should receive it.
  kill(child_pid, SIGUSR1);
  mask_helper.waitForSignal(SIGUSR1);

  // Wait for the child process to terminate
  EXPECT_TRUE(fork_helper.WaitForChildren());
}

TEST_F(CgroupFreezerTest, FreezeNestedCgroups) {
  pid_t parent_pid = getpid();
  test_helper::ForkHelper fork_helper;

  // There is no guaranteed order of SIGUSR1 and SIGUSR2 coming from descendant cgroups. Use two
  // signal sets to catch accordingly.
  test_helper::SignalMaskHelper mask_helper_1;
  mask_helper_1.blockSignal(SIGUSR1);
  test_helper::SignalMaskHelper mask_helper_2;
  mask_helper_2.blockSignal(SIGUSR2);

  // Freeze the parent
  FreezeCgroup(test_cgroup_path());

  pid_t child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR1, 1, parent_pid); });
  test_pids_.push_back(child_pid);

  std::string child_cgroup = test_cgroup_path() + "/child";
  CreateChildCgroup(child_cgroup);
  AddProcToCgroup(child_pid, child_cgroup);

  pid_t grand_child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR2, 1, parent_pid); });
  test_pids_.push_back(grand_child_pid);

  std::string grand_child_cgroup = child_cgroup + "/grandchild";
  CreateChildCgroup(grand_child_cgroup);
  AddProcToCgroup(grand_child_pid, grand_child_cgroup);

  // Send signal; frozen child should *not* receive it.
  kill(child_pid, SIGUSR1);
  EXPECT_THAT(mask_helper_1.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));

  // Send signal; frozen grandchild should *not* receive it.
  kill(grand_child_pid, SIGUSR2);
  EXPECT_THAT(mask_helper_2.timedWaitForSignal(SIGUSR2, 100), SyscallFailsWithErrno(EAGAIN));

  // Keep the child frozen, but thaw the parent
  FreezeCgroup(child_cgroup);
  ThawCgroup(test_cgroup_path());
  EXPECT_THAT(mask_helper_1.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));
  EXPECT_THAT(mask_helper_2.timedWaitForSignal(SIGUSR2, 100), SyscallFailsWithErrno(EAGAIN));

  // Thaw the child cgroup
  ThawCgroup(child_cgroup);

  // Child and grandchild will process the last signal after thawed.
  mask_helper_1.waitForSignal(SIGUSR1);
  mask_helper_2.waitForSignal(SIGUSR2);

  // Wait for the child process to terminate
  EXPECT_TRUE(fork_helper.WaitForChildren());
}

TEST_F(CgroupFreezerTest, CheckStateInEventsFile) {
  FreezeCgroup(test_cgroup_path());
  EXPECT_TRUE(IsCgroupFrozen(test_cgroup_path()));
  ThawCgroup(test_cgroup_path());
  EXPECT_FALSE(IsCgroupFrozen(test_cgroup_path()));
}

TEST_F(CgroupFreezerTest, FreezerState) {
  std::string parent_cgroup = test_cgroup_path();
  std::string child_cgroup = parent_cgroup + "/child";
  std::string grand_child_cgroup = child_cgroup + "/grandchild";
  CreateChildCgroup(child_cgroup);
  CreateChildCgroup(grand_child_cgroup);

  FreezeCgroup(parent_cgroup);

  // Frozen parent shouldn't impact the child self state.
  EXPECT_TRUE(IsCgroupSelfFrozen(parent_cgroup));
  EXPECT_FALSE(IsCgroupSelfFrozen(child_cgroup));
  EXPECT_FALSE(IsCgroupSelfFrozen(grand_child_cgroup));

  // The frozen state in the descendants should be changed.
  EXPECT_TRUE(IsCgroupFrozen(parent_cgroup));
  EXPECT_TRUE(IsCgroupFrozen(child_cgroup));
  EXPECT_TRUE(IsCgroupFrozen(grand_child_cgroup));

  // Thaw the child cgroup while the parent is still frozen
  ThawCgroup(child_cgroup);
  EXPECT_TRUE(IsCgroupFrozen(child_cgroup));
  EXPECT_FALSE(IsCgroupSelfFrozen(child_cgroup));

  // Thaw the parent cgroup
  ThawCgroup(parent_cgroup);

  EXPECT_FALSE(IsCgroupFrozen(parent_cgroup));
  EXPECT_FALSE(IsCgroupFrozen(child_cgroup));
  EXPECT_FALSE(IsCgroupFrozen(grand_child_cgroup));

  // Freeze the parent and child cgroups and thaw the parent
  FreezeCgroup(parent_cgroup);
  FreezeCgroup(child_cgroup);
  ThawCgroup(parent_cgroup);
  EXPECT_FALSE(IsCgroupFrozen(parent_cgroup));
  EXPECT_TRUE(IsCgroupFrozen(child_cgroup));
  EXPECT_TRUE(IsCgroupFrozen(grand_child_cgroup));
  EXPECT_TRUE(IsCgroupSelfFrozen(child_cgroup));
  EXPECT_FALSE(IsCgroupSelfFrozen(grand_child_cgroup));
}

TEST_F(CgroupFreezerTest, MoveProcess) {
  // This test verifies that moving a process between frozen and thawed cgroups correctly affects
  // signal delivery.  It creates two frozen child cgroups and starts a child process in one of
  // them.  Signals sent to the child process should be blocked while it's in a frozen cgroup and
  // delivered once it's moved to a thawed cgroup.

  pid_t parent_pid = getpid();
  test_helper::ForkHelper fork_helper;
  test_helper::SignalMaskHelper mask_helper;
  mask_helper.blockSignal(SIGUSR1);

  std::string frozen_child1_cgroup = test_cgroup_path() + "/frozen_child_1";
  CreateChildCgroup(frozen_child1_cgroup);
  FreezeCgroup(frozen_child1_cgroup);
  std::string frozen_child2_cgroup = test_cgroup_path() + "/frozen_child_2";
  CreateChildCgroup(frozen_child2_cgroup);
  FreezeCgroup(frozen_child2_cgroup);

  pid_t child_pid =
      fork_helper.RunInForkedProcess([parent_pid] { ChildWaitSignal(SIGUSR1, 2, parent_pid); });
  test_pids_.push_back(child_pid);

  AddProcToCgroup(child_pid, frozen_child1_cgroup);
  kill(child_pid, SIGUSR1);
  EXPECT_THAT(mask_helper.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));

  // Put the child proc into the root cgroup
  AddProcToCgroup(child_pid, root_cgroup_path());
  mask_helper.waitForSignal(SIGUSR1);

  AddProcToCgroup(child_pid, frozen_child2_cgroup);
  kill(child_pid, SIGUSR1);
  EXPECT_THAT(mask_helper.timedWaitForSignal(SIGUSR1, 100), SyscallFailsWithErrno(EAGAIN));

  AddProcToCgroup(child_pid, test_cgroup_path());
  mask_helper.waitForSignal(SIGUSR1);

  EXPECT_TRUE(fork_helper.WaitForChildren());
}