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

// Copyright 2026 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/eventfd.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <unistd.h>

#include <fbl/unique_fd.h>
#include <gtest/gtest.h>
#include <linux/securebits.h>

#include "src/starnix/tests/syscalls/cpp/syscall_matchers.h"
#include "src/starnix/tests/syscalls/cpp/test_helper.h"
#include "third_party/android/platform/bionic/libc/kernel/uapi/linux/bpf.h"

#ifndef SYS_userfaultfd
#if defined(__x86_64__)
#define SYS_userfaultfd 323
#elif defined(__aarch64__)
#define SYS_userfaultfd 282
#elif defined(__riscv)
#define SYS_userfaultfd 282
#endif
#endif

#ifndef UFFD_USER_MODE_ONLY
#define UFFD_USER_MODE_ONLY 1
#endif

namespace {

constexpr uid_t kRootUid = 0;
constexpr gid_t kRootGid = 0;
constexpr uid_t kTestUid = 10001;
constexpr gid_t kTestGid = 10002;

struct AnonInodeTestParam {
  std::string name;
  std::function<fbl::unique_fd()> create_fd;
  bool expect_shared;
};

class AnonInodeTest : public ::testing::TestWithParam<AnonInodeTestParam> {};

TEST_P(AnonInodeTest, ModeAndOwnership) {
  if (!test_helper::HasSysAdmin()) {
    GTEST_SKIP() << "This test requires CAP_SYS_ADMIN";
  }

  test_helper::ForkHelper helper;
  helper.RunInForkedProcess([]() {
    // Creating BPF nodes requires CAP_BPF so keep capabilities when changing eUID.
    ASSERT_THAT(prctl(PR_SET_SECUREBITS, SECBIT_NO_SETUID_FIXUP), SyscallSucceeds());

    ASSERT_THAT(setegid(kTestGid), SyscallSucceeds());
    ASSERT_THAT(seteuid(kTestUid), SyscallSucceeds());

    const AnonInodeTestParam& param = GetParam();
    fbl::unique_fd fd = param.create_fd();
    ASSERT_THAT(fd.get(), SyscallSucceeds());

    struct stat st;
    ASSERT_THAT(fstat(fd.get(), &st), SyscallSucceeds());

    // All anonymous nodes should be readable and writable only by the owner.
    EXPECT_EQ(st.st_mode, static_cast<mode_t>(0600));

    if (param.expect_shared) {
      // Shared inodes do not inherit ownership, they are owned by root.
      EXPECT_EQ(st.st_uid, kRootUid);
      EXPECT_EQ(st.st_gid, kRootGid);
    } else {
      // Unique inodes inherit ownership.
      EXPECT_EQ(st.st_uid, kTestUid);
      EXPECT_EQ(st.st_gid, kTestGid);
    }
  });

  EXPECT_TRUE(helper.WaitForChildren());
}

TEST_P(AnonInodeTest, SingletonNode) {
  if (!test_helper::HasSysAdmin()) {
    GTEST_SKIP() << "This test requires CAP_SYS_ADMIN";
  }

  const AnonInodeTestParam& param = GetParam();
  fbl::unique_fd fd1 = param.create_fd();
  ASSERT_THAT(fd1.get(), SyscallSucceeds());

  fbl::unique_fd fd2 = param.create_fd();
  ASSERT_THAT(fd2.get(), SyscallSucceeds());

  struct stat st1, st2;
  ASSERT_THAT(fstat(fd1.get(), &st1), SyscallSucceeds());
  ASSERT_THAT(fstat(fd2.get(), &st2), SyscallSucceeds());

  if (param.expect_shared) {
    EXPECT_EQ(st1.st_ino, st2.st_ino);
  } else {
    EXPECT_NE(st1.st_ino, st2.st_ino);
  }
}

fbl::unique_fd CreateUserfaultfd() {
  int flags = O_CLOEXEC | O_NONBLOCK | UFFD_USER_MODE_ONLY;
  return fbl::unique_fd(static_cast<int>(syscall(SYS_userfaultfd, flags)));
}

fbl::unique_fd CreateEventfd() { return fbl::unique_fd(eventfd(0, 0)); }

fbl::unique_fd CreateBpfMap() {
  union bpf_attr attr;
  memset(&attr, 0, sizeof(attr));
  attr.map_type = BPF_MAP_TYPE_ARRAY;
  attr.key_size = sizeof(int);
  attr.value_size = sizeof(int);
  attr.max_entries = 1;
  return fbl::unique_fd(static_cast<int>(syscall(SYS_bpf, BPF_MAP_CREATE, &attr, sizeof(attr))));
}

INSTANTIATE_TEST_SUITE_P(All, AnonInodeTest,
                         ::testing::Values(
                             AnonInodeTestParam{
                                 .name = "Userfaultfd",
                                 .create_fd = CreateUserfaultfd,
                                 .expect_shared = false,
                             },
                             AnonInodeTestParam{
                                 .name = "Eventfd",
                                 .create_fd = CreateEventfd,
                                 .expect_shared = true,
                             },
                             AnonInodeTestParam{
                                 .name = "BpfMap",
                                 .create_fd = CreateBpfMap,
                                 .expect_shared = true,
                             }),
                         [](const ::testing::TestParamInfo<AnonInodeTestParam>& info) {
                           return info.param.name;
                         });

}  // namespace