blob: 2e879e8a3d638c620ff9b39b8023d1dca879965e [file]
// Copyright 2023 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 <dirent.h>
#include <fcntl.h>
#include <grp.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <unistd.h>
#include <filesystem>
#include <fstream>
#include <gtest/gtest.h>
#include <linux/capability.h>
#include "src/lib/files/file.h"
#include "src/lib/fxl/strings/string_printf.h"
#include "src/starnix/tests/syscalls/cpp/capabilities_helper.h"
#include "src/starnix/tests/syscalls/cpp/syscall_matchers.h"
#include "src/starnix/tests/syscalls/cpp/test_helper.h"
using testing::ElementsAre;
using testing::IsEmpty;
namespace {
struct DirEntry {
std::string name;
uint8_t type;
ino_t inode_num;
off_t offset;
static DirEntry Dir(const std::string& name) {
return DirEntry{
.name = name,
.type = DT_DIR,
};
}
static DirEntry CharDev(const std::string& name) {
return DirEntry{
.name = name,
.type = DT_CHR,
};
}
static DirEntry File(const std::string& name) {
return DirEntry{
.name = name,
.type = DT_REG,
};
}
bool operator<(const DirEntry& rhs) const { return name < rhs.name; }
bool operator==(const DirEntry& rhs) const { return name == rhs.name && type == rhs.type; }
};
std::ostream& operator<<(std::ostream& stream, DirEntry const& value) {
return stream << "DirEntry(\"" << value.name << "\", type=" << static_cast<int>(value.type)
<< ")";
}
std::vector<DirEntry> ReadDir(const std::string& path) {
std::vector<DirEntry> result;
DIR* dir = opendir(path.c_str());
if (!dir) {
ADD_FAILURE() << "opendir() failed for " << path << " errno=" << errno;
return result;
}
struct dirent* de;
errno = 0;
bool found_dot = false;
bool found_dot_dot = false;
while ((de = readdir(dir)) != nullptr) {
if (std::string(de->d_name) == ".") {
EXPECT_FALSE(found_dot);
EXPECT_EQ(de->d_type, DT_DIR);
found_dot = true;
} else if (std::string(de->d_name) == "..") {
EXPECT_FALSE(found_dot_dot);
EXPECT_EQ(de->d_type, DT_DIR);
found_dot_dot = true;
} else {
result.push_back(DirEntry{
.name = de->d_name,
.type = de->d_type,
.inode_num = de->d_ino,
.offset = de->d_off,
});
}
}
closedir(dir);
if (errno != 0) {
ADD_FAILURE() << "readdir() failed with errno=" << errno;
return result;
}
EXPECT_TRUE(found_dot);
EXPECT_TRUE(found_dot_dot);
std::sort(result.begin(), result.end());
return result;
}
std::string ReadFileContent(const std::string& path) {
std::string content;
EXPECT_TRUE(files::ReadFileToString(path.c_str(), &content));
return content;
}
bool IsWhiteout(const std::string& path) {
struct stat s;
return stat(path.c_str(), &s) == 0 && (s.st_mode & S_IFMT) == S_IFCHR && s.st_rdev == 0;
}
std::string Readlink(const std::string& path) {
std::string result;
result.resize(256);
ssize_t r = readlink(path.c_str(), result.data(), static_cast<int>(result.size()));
if (r < 0) {
ADD_FAILURE() << "readlink(" << path << ") failed with errno=" << errno;
return "";
}
result.resize(r);
return result;
}
class OverlayFsTest : public ::testing::Test {
protected:
void SetUp() override {
// TODO(https://fxbug.dev/317285180) don't skip on baseline
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Not running with sysadmin capabilities, skipping suite.";
}
ASSERT_FALSE(temp_dir_.path().empty());
overlay_ = temp_dir_.path() + "/overlay";
ASSERT_THAT(mkdir(overlay_.c_str(), 0700), SyscallSucceeds());
lower_ = temp_dir_.path() + "/lower";
ASSERT_THAT(mkdir(lower_.c_str(), 0700), SyscallSucceeds());
upper_base_ = temp_dir_.path() + "/upper_base";
ASSERT_THAT(mkdir(upper_base_.c_str(), 0700), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(InitUpperDirs());
}
void TearDown() override {
if (!::testing::Test::IsSkipped()) {
ASSERT_THAT(umount(overlay_.c_str()), SyscallSucceeds());
}
}
void InitUpperDirs() {
upper_ = upper_base_ + "/upper";
ASSERT_THAT(mkdir(upper_.c_str(), 0700), SyscallSucceeds());
work_ = upper_base_ + "/work";
ASSERT_THAT(mkdir(work_.c_str(), 0700), SyscallSucceeds());
}
void Mount() {
std::string options = fxl::StringPrintf("lowerdir=%s,upperdir=%s,workdir=%s", lower_.c_str(),
upper_.c_str(), work_.c_str());
ASSERT_THAT(mount(nullptr, overlay_.c_str(), "overlay", 0, options.c_str()), SyscallSucceeds());
}
std::string ReadOverlayFileContent(const std::string& file) {
return ReadFileContent(overlay_ + file);
}
test_helper::ScopedTempDir temp_dir_;
std::string lower_;
std::string upper_;
std::string upper_base_;
std::string work_;
std::string overlay_;
};
TEST_F(OverlayFsTest, ListRoot) {
ASSERT_TRUE(files::WriteFile(lower_ + "/a", "lower/a"));
ASSERT_TRUE(files::WriteFile(lower_ + "/c", "lower/c"));
ASSERT_TRUE(files::WriteFile(upper_ + "/b", "upper/b"));
ASSERT_TRUE(files::WriteFile(upper_ + "/c", "upper/c"));
ASSERT_NO_FATAL_FAILURE(Mount());
std::vector<DirEntry> list = ReadDir(overlay_);
EXPECT_THAT(list, ElementsAre(DirEntry::File("a"), DirEntry::File("b"), DirEntry::File("c")));
std::vector<DirEntry> lower_list = ReadDir(lower_);
std::vector<DirEntry> upper_list = ReadDir(upper_);
// Inode number copied from the source file systems.
EXPECT_EQ(list[0].inode_num, lower_list[0].inode_num);
EXPECT_EQ(list[1].inode_num, upper_list[0].inode_num);
EXPECT_EQ(list[2].inode_num, upper_list[1].inode_num);
}
TEST_F(OverlayFsTest, RootAttributes) {
// Use distinct modes for lower and upper roots.
ASSERT_THAT(chmod(lower_.c_str(), 0755), SyscallSucceeds());
ASSERT_THAT(chmod(upper_.c_str(), 0711), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(Mount());
struct stat lower_stat, upper_stat, overlay_stat;
ASSERT_THAT(stat(lower_.c_str(), &lower_stat), SyscallSucceeds());
ASSERT_THAT(stat(upper_.c_str(), &upper_stat), SyscallSucceeds());
ASSERT_THAT(stat(overlay_.c_str(), &overlay_stat), SyscallSucceeds());
ASSERT_NE(upper_stat.st_mode, lower_stat.st_mode);
// Overlay root should have the same mode as the upper root.
EXPECT_EQ(overlay_stat.st_mode, upper_stat.st_mode);
}
TEST_F(OverlayFsTest, ListSubdir) {
ASSERT_THAT(mkdir((lower_ + "/sub").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/sub/a", "a"));
ASSERT_THAT(mkdir((upper_ + "/sub").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/sub/b", "b"));
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadDir(overlay_ + "/sub"), (std::vector{DirEntry::File("a"), DirEntry::File("b")}));
}
TEST_F(OverlayFsTest, DirAndFile) {
ASSERT_TRUE(files::WriteFile(lower_ + "/sub", "a"));
ASSERT_THAT(mkdir((upper_ + "/sub").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/sub/b", "b"));
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadDir(overlay_), (std::vector{DirEntry::Dir("sub")}));
EXPECT_EQ(ReadDir(overlay_ + "/sub"), (std::vector{DirEntry::File("b")}));
EXPECT_EQ(ReadOverlayFileContent("/sub/b"), "b");
}
TEST_F(OverlayFsTest, ReadFileLower) {
ASSERT_TRUE(files::WriteFile(lower_ + "/a", "1"));
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadOverlayFileContent("/a"), "1");
}
TEST_F(OverlayFsTest, ReadFileUpper) {
ASSERT_TRUE(files::WriteFile(upper_ + "/a", "2"));
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadOverlayFileContent("/a"), "2");
}
TEST_F(OverlayFsTest, ReadFileBoth) {
ASSERT_TRUE(files::WriteFile(lower_ + "/a", "1"));
ASSERT_TRUE(files::WriteFile(upper_ + "/a", "2"));
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadOverlayFileContent("/a"), "2");
}
TEST_F(OverlayFsTest, UnmountBase) {
ASSERT_THAT(mount(nullptr, lower_.c_str(), "tmpfs", 0, nullptr), SyscallSucceeds());
ASSERT_THAT(mount(nullptr, upper_base_.c_str(), "tmpfs", 0, nullptr), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(InitUpperDirs());
ASSERT_TRUE(files::WriteFile(lower_ + "/a", "1"));
ASSERT_TRUE(files::WriteFile(upper_ + "/b", "2"));
ASSERT_NO_FATAL_FAILURE(Mount());
// We should be able to unmount base file systems. Overlay should still be accessible.
ASSERT_THAT(umount(lower_.c_str()), SyscallSucceeds());
ASSERT_THAT(umount(upper_base_.c_str()), SyscallSucceeds());
EXPECT_EQ(ReadOverlayFileContent("/a"), "1");
EXPECT_EQ(ReadOverlayFileContent("/b"), "2");
}
TEST_F(OverlayFsTest, MountSubdir) {
ASSERT_THAT(mkdir((lower_ + "/sub").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/sub/a", "1"));
ASSERT_THAT(mkdir((upper_ + "/sub").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/sub/b", "2"));
// Mount new FS over the subdirs. That shouldn't affect the files visible to overlayfs.
ASSERT_THAT(mount(nullptr, (lower_ + "/sub").c_str(), "tmpfs", 0, nullptr), SyscallSucceeds());
ASSERT_THAT(mount(nullptr, (upper_ + "/sub").c_str(), "tmpfs", 0, nullptr), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/sub/c", "3"));
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadOverlayFileContent("/sub/a"), "1");
EXPECT_EQ(ReadOverlayFileContent("/sub/b"), "2");
EXPECT_EQ(ReadDir(overlay_ + "/sub"), (std::vector{DirEntry::File("a"), DirEntry::File("b")}));
}
TEST_F(OverlayFsTest, RemovedFiles) {
// Char device with `type=0` is a removed file marker. It should not be listed in the
// overlay FS.
ASSERT_THAT(mknod((lower_ + "/a").c_str(), S_IFCHR, 0), SyscallSucceeds());
ASSERT_THAT(mknod((lower_ + "/b").c_str(), S_IFCHR, 1), SyscallSucceeds());
ASSERT_THAT(mknod((upper_ + "/c").c_str(), S_IFCHR, 0), SyscallSucceeds());
ASSERT_THAT(mknod((upper_ + "/d").c_str(), S_IFCHR, 1), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(Mount());
EXPECT_EQ(ReadDir(overlay_), (std::vector{DirEntry::CharDev("b"), DirEntry::CharDev("d")}));
}
TEST_F(OverlayFsTest, MknodZeroDevice) {
ASSERT_NO_FATAL_FAILURE(Mount());
// OverlayFS reserves character devices with device ID 0 for whiteouts.
// Attempts to create one via mknod should fail with EPERM, even if the caller has CAP_MKNOD.
ASSERT_TRUE(test_helper::HasCapability(CAP_MKNOD));
EXPECT_THAT(mknod((overlay_ + "/zero_chr_dev").c_str(), S_IFCHR | 0600, 0),
SyscallFailsWithErrno(EPERM));
EXPECT_THAT(mknod((overlay_ + "/zero_blk_dev").c_str(), S_IFBLK | 0600, 0), SyscallSucceeds());
}
TEST_F(OverlayFsTest, UnlinkLower) {
ASSERT_THAT(mkdir((lower_ + "/s").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/s/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
// Remove the file.
ASSERT_THAT(unlink((overlay_ + "/s/a").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_ + "/s"), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s/a").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
// Whiteout should be created in the upper dir.
EXPECT_TRUE(IsWhiteout(upper_ + "/s/a"));
// Remove the directory.
ASSERT_THAT(rmdir((overlay_ + "/s").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
// Whiteout should be created in the upper dir.
EXPECT_TRUE(IsWhiteout(upper_ + "/s"));
// Lower file should not be touched.
EXPECT_EQ(ReadFileContent(lower_ + "/s/a"), "a");
}
TEST_F(OverlayFsTest, UnlinkNonEmptyDir) {
ASSERT_THAT(mkdir((upper_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mkdir((lower_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
// Try removing non-empty dir. This is expected to fail.
ASSERT_THAT(rmdir((overlay_ + "/d").c_str()), SyscallFailsWithErrno(ENOTEMPTY));
// Directory should still exist.
EXPECT_EQ(ReadDir(overlay_), (std::vector{DirEntry::Dir("d")}));
EXPECT_EQ(ReadDir(overlay_ + "/d"), (std::vector{DirEntry::File("a")}));
// No changes to the lower and upper FS.
EXPECT_THAT(ReadDir(upper_ + "/d"), IsEmpty());
EXPECT_EQ(ReadDir(lower_ + "/d"), (std::vector{DirEntry::File("a")}));
}
TEST_F(OverlayFsTest, UnlinkUpper) {
ASSERT_THAT(mkdir((upper_ + "/s").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/s/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(unlink((overlay_ + "/s/a").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_ + "/s"), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s/a").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
EXPECT_THAT(ReadDir(lower_), IsEmpty());
EXPECT_THAT(ReadDir(upper_ + "/s"), IsEmpty());
// Remove the directory.
ASSERT_THAT(rmdir((overlay_ + "/s").c_str()), SyscallSucceeds());
EXPECT_THAT(open((overlay_ + "/s").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
EXPECT_THAT(ReadDir(overlay_), IsEmpty());
EXPECT_THAT(ReadDir(lower_), IsEmpty());
EXPECT_THAT(ReadDir(upper_), IsEmpty());
}
TEST_F(OverlayFsTest, UnlinkBoth) {
ASSERT_THAT(mkdir((lower_ + "/s").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/s/a", "a"));
ASSERT_THAT(mkdir((upper_ + "/s").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/s/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
// Remove the file.
ASSERT_THAT(unlink((overlay_ + "/s/a").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_ + "/s"), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s/a").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
// Whiteout should be created in the upper dir.
EXPECT_TRUE(IsWhiteout(upper_ + "/s/a"));
// Remove the directory.
ASSERT_THAT(rmdir((overlay_ + "/s").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
// Whiteout should be created in the upper dir.
EXPECT_TRUE(IsWhiteout(upper_ + "/s"));
// Lower file should not be touched.
EXPECT_EQ(ReadFileContent(lower_ + "/s/a"), "a");
}
TEST_F(OverlayFsTest, RecreateDir) {
ASSERT_THAT(mkdir((lower_ + "/s").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/s/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
// Remove the file.
ASSERT_THAT(unlink((overlay_ + "/s/a").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_ + "/s"), IsEmpty());
// Whiteout should be created in the upper dir.
EXPECT_TRUE(IsWhiteout(upper_ + "/s/a"));
// Remove the directory.
ASSERT_THAT(rmdir((overlay_ + "/s").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_), IsEmpty());
// Whiteout should be created in the upper dir.
EXPECT_TRUE(IsWhiteout(upper_ + "/s"));
// Create the dir again.
ASSERT_THAT(mkdir((overlay_ + "/s").c_str(), 0700), SyscallSucceeds());
// The new dir should be empty.
EXPECT_THAT(ReadDir(overlay_ + "/s"), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s/a").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
// Lower file should not be touched.
EXPECT_EQ(ReadFileContent(lower_ + "/s/a"), "a");
}
TEST_F(OverlayFsTest, RecreateFile) {
ASSERT_THAT(mkdir((lower_ + "/s").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/s/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
// Remove the file.
ASSERT_THAT(unlink((overlay_ + "/s/a").c_str()), SyscallSucceeds());
EXPECT_THAT(ReadDir(overlay_ + "/s"), IsEmpty());
EXPECT_THAT(open((overlay_ + "/s/a").c_str(), O_RDONLY), SyscallFailsWithErrno(ENOENT));
// Try creating the file again
ASSERT_TRUE(files::WriteFile(overlay_ + "/s/a", "b"));
EXPECT_EQ(ReadFileContent(overlay_ + "/s/a"), "b");
// It should be written to the upper dir.
EXPECT_EQ(ReadFileContent(upper_ + "/s/a"), "b");
// Lower file should not be touched.
EXPECT_EQ(ReadFileContent(lower_ + "/s/a"), "a");
}
TEST_F(OverlayFsTest, CreateDir) {
ASSERT_THAT(mkdir((lower_ + "/d1").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mkdir((lower_ + "/d2").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mkdir((upper_ + "/d1").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mkdir((upper_ + "/d3").c_str(), 0700), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(Mount());
// Make new dirs.
ASSERT_THAT(mkdir((overlay_ + "/d1/1").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mkdir((overlay_ + "/d2/2").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mkdir((overlay_ + "/d3/3").c_str(), 0700), SyscallSucceeds());
// Verify that the dirs were created.
EXPECT_EQ(ReadDir(overlay_ + "/d1"), (std::vector{DirEntry::Dir("1")}));
EXPECT_EQ(ReadDir(overlay_ + "/d2"), (std::vector{DirEntry::Dir("2")}));
EXPECT_EQ(ReadDir(overlay_ + "/d3"), (std::vector{DirEntry::Dir("3")}));
// New dirs are empty.
EXPECT_THAT(ReadDir(overlay_ + "/d1/1"), IsEmpty());
EXPECT_THAT(ReadDir(overlay_ + "/d2/2"), IsEmpty());
EXPECT_THAT(ReadDir(overlay_ + "/d3/3"), IsEmpty());
// Lower FS should not change.
EXPECT_EQ(ReadDir(lower_), (std::vector{DirEntry::Dir("d1"), DirEntry::Dir("d2")}));
EXPECT_THAT(ReadDir(lower_ + "/d1"), IsEmpty());
EXPECT_THAT(ReadDir(lower_ + "/d2"), IsEmpty());
// New parent dir created in the upper FS.
EXPECT_EQ(ReadDir(upper_),
(std::vector{DirEntry::Dir("d1"), DirEntry::Dir("d2"), DirEntry::Dir("d3")}));
}
TEST_F(OverlayFsTest, CreateFile) {
ASSERT_THAT(mkdir((lower_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_TRUE(files::WriteFile(overlay_ + "/d/a", "foo"));
EXPECT_EQ(ReadFileContent(overlay_ + "/d/a"), "foo");
// New file should be created in the upper dir.
EXPECT_EQ(ReadDir(upper_), (std::vector{DirEntry::Dir("d")}));
EXPECT_EQ(ReadFileContent(upper_ + "/d/a"), "foo");
// Lower FS should not change.
EXPECT_THAT(ReadDir(lower_ + "/d"), IsEmpty());
}
TEST_F(OverlayFsTest, CreateSymlink) {
ASSERT_THAT(mkdir((lower_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(symlink("symlink_target", (overlay_ + "/d/a").c_str()), SyscallSucceeds());
EXPECT_EQ(Readlink(overlay_ + "/d/a"), "symlink_target");
// New file should be created in the upper dir.
EXPECT_EQ(ReadDir(upper_), (std::vector{DirEntry::Dir("d")}));
EXPECT_EQ(Readlink(upper_ + "/d/a"), "symlink_target");
// Lower FS should not change.
EXPECT_THAT(ReadDir(lower_ + "/d"), IsEmpty());
}
TEST_F(OverlayFsTest, RewriteFile) {
ASSERT_THAT(mkdir((lower_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_TRUE(files::WriteFile(overlay_ + "/d/a", "foo"));
EXPECT_EQ(ReadFileContent(overlay_ + "/d/a"), "foo");
// New file should be created in the upper dir.
EXPECT_EQ(ReadDir(upper_), (std::vector{DirEntry::Dir("d")}));
EXPECT_EQ(ReadFileContent(upper_ + "/d/a"), "foo");
// Lower FS should not change.
EXPECT_EQ(ReadFileContent(lower_ + "/d/a"), "a");
}
TEST_F(OverlayFsTest, AppendFile) {
ASSERT_THAT(mkdir((lower_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d/a", "a-"));
ASSERT_NO_FATAL_FAILURE(Mount());
{
std::ofstream stream;
stream.open(overlay_ + "/d/a", std::ios_base::app);
stream << "foo";
ASSERT_FALSE(stream.fail());
}
EXPECT_EQ(ReadFileContent(overlay_ + "/d/a"), "a-foo");
// New file should be created in the upper dir.
EXPECT_EQ(ReadDir(upper_), (std::vector{DirEntry::Dir("d")}));
EXPECT_EQ(ReadFileContent(upper_ + "/d/a"), "a-foo");
// Lower FS should not change.
EXPECT_EQ(ReadFileContent(lower_ + "/d/a"), "a-");
}
TEST_F(OverlayFsTest, Link) {
ASSERT_THAT(mkdir((lower_ + "/d").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(link((overlay_ + "/d/a").c_str(), (overlay_ + "/d/b").c_str()), SyscallSucceeds());
// New file should be created in the upper dir.
auto list = ReadDir(upper_ + "/d");
EXPECT_EQ(list, (std::vector{DirEntry::File("a"), DirEntry::File("b")}));
EXPECT_EQ(list[0].inode_num, list[1].inode_num);
// Write new content. Both files should be updated.
ASSERT_TRUE(files::WriteFile(overlay_ + "/d/a", "new"));
EXPECT_EQ(ReadFileContent(upper_ + "/d/a"), "new");
EXPECT_EQ(ReadFileContent(upper_ + "/d/b"), "new");
// Lower FS should not change.
EXPECT_EQ(ReadDir(lower_ + "/d"), (std::vector{DirEntry::File("a")}));
EXPECT_EQ(ReadFileContent(lower_ + "/d/a"), "a");
}
TEST_F(OverlayFsTest, UpdateAfterOpen) {
ASSERT_TRUE(files::WriteFile(lower_ + "/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
std::ifstream file(overlay_ + "/a", std::ios::in);
ASSERT_TRUE(files::WriteFile(overlay_ + "/a", "updated"));
// Start reading from `file`. We should get new content, written after the file was open.
std::string data;
file >> data;
EXPECT_EQ(data, "updated");
}
TEST_F(OverlayFsTest, RenameFile) {
ASSERT_THAT(mkdir((lower_ + "/d1").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d1/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(mkdir((overlay_ + "/d2").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(rename((overlay_ + "/d1/a").c_str(), (overlay_ + "/d2/b").c_str()),
SyscallSucceeds());
EXPECT_EQ(ReadDir(overlay_), (std::vector{DirEntry::Dir("d1"), DirEntry::Dir("d2")}));
EXPECT_EQ(ReadFileContent(overlay_ + "/d2/b"), "a");
// New file should be created in the upper FS.
EXPECT_EQ(ReadFileContent(upper_ + "/d2/b"), "a");
// Lower FS should not change.
EXPECT_EQ(ReadDir(lower_), (std::vector{DirEntry::Dir("d1")}));
EXPECT_EQ(ReadFileContent(lower_ + "/d1/a"), "a");
}
TEST_F(OverlayFsTest, RenameNonexistent) {
ASSERT_THAT(mkdir((lower_ + "/d1").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d1/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(rename((overlay_ + "/d1/b").c_str(), (overlay_ + "/d1/c").c_str()),
SyscallFailsWithErrno(ENOENT));
}
TEST_F(OverlayFsTest, RenameDir) {
ASSERT_THAT(mkdir((lower_ + "/d1").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/d1/a", "a"));
ASSERT_THAT(mkdir((upper_ + "/d1").c_str(), 0700), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(upper_ + "/d1/a", "a"));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(rename((overlay_ + "/d1").c_str(), (overlay_ + "/d2").c_str()),
SyscallFailsWithErrno(EXDEV));
// Lower FS should not change.
EXPECT_EQ(ReadDir(lower_), (std::vector{DirEntry::Dir("d1")}));
EXPECT_EQ(ReadFileContent(lower_ + "/d1/a"), "a");
}
// During `exec()` the old address-space is torn-down, which can result in locks being taken while
// dropping `mmap()`ed resources. Reproduce an example of this situation and validate that it does
// not trigger a lock-dependency panic.
// This is a regression test for https://fxbug.dev/540127035
TEST_F(OverlayFsTest, DropUncachedDirEntryDuringExecPassesLockDep) {
ASSERT_NO_FATAL_FAILURE(Mount());
std::string file_path = overlay_ + "/mapped_file";
ASSERT_TRUE(files::WriteFile(file_path, "test content"));
const std::string exit_zero_path = test_helper::GetTestResourcePath("exit_zero");
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
// 1. Open the file on OverlayFS and map it into the process address space.
int fd = open(file_path.c_str(), O_RDONLY);
ASSERT_THAT(fd, SyscallSucceeds());
void* addr = mmap(nullptr, sysconf(_SC_PAGESIZE), PROT_READ, MAP_PRIVATE, fd, 0);
ASSERT_NE(addr, MAP_FAILED);
// 2. Close the file descriptor before calling execve().
// This ensures that the FileMapping in MemoryManager holds the sole
// remaining strong reference to the underlying DirEntry.
ASSERT_THAT(close(fd), SyscallSucceeds());
// 3. Calling execve() replaces the MemoryManager, dropping the FileMapping.
// On uncached filesystems, this drops the last strong reference to DirEntry
// and triggers child removal from the parent directory while TaskCredsLock
// is held by execve().
char* const argv[] = {const_cast<char*>(exit_zero_path.c_str()), nullptr};
char* const envp[] = {nullptr};
EXPECT_THAT(execve(exit_zero_path.c_str(), argv, envp), SyscallSucceeds());
});
ASSERT_TRUE(helper.WaitForChildren());
}
class OverlayFsAccessTest : public OverlayFsTest {
protected:
void SetUp() override {
OverlayFsTest::SetUp();
if (IsSkipped()) {
return;
}
// Allow users other than the mounter to traverse to the overlay directory, and write to it.
ASSERT_THAT(chmod(temp_dir_.path().c_str(), 0711), SyscallSucceeds());
ASSERT_THAT(chmod(overlay_.c_str(), 0777), SyscallSucceeds());
}
void MountWithReadableAndWritableFiles() {
ASSERT_TRUE(files::WriteFile(lower_ + "/readable", "readable"));
ASSERT_THAT(chmod((lower_ + "/readable").c_str(), 0644), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/lower_readable", "lower_readable"));
ASSERT_THAT(chmod((lower_ + "/lower_readable").c_str(), 0644), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/upper_readable", "upper_readable"));
ASSERT_THAT(chmod((lower_ + "/upper_readable").c_str(), 0600), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/writable", "writable"));
ASSERT_THAT(chmod((lower_ + "/writable").c_str(), 0666), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/lower_writable", "lower_writable"));
ASSERT_THAT(chmod((lower_ + "/lower_writable").c_str(), 0666), SyscallSucceeds());
ASSERT_TRUE(files::WriteFile(lower_ + "/upper_writable", "upper_writable"));
ASSERT_THAT(chmod((lower_ + "/upper_writable").c_str(), 0600), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(Mount());
// Allow all users to read, write and traverse the root of the overlay.
ASSERT_THAT(chmod(overlay_.c_str(), 0777), SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/lower_readable").c_str(), 0600), SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/upper_readable").c_str(), 0644), SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/lower_writable").c_str(), 0600), SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/upper_writable").c_str(), 0666), SyscallSucceeds());
}
static void StageExecutable(const std::string& src, const std::string& dst, mode_t mode) {
std::error_code ec;
ASSERT_TRUE(std::filesystem::copy_file(src, dst, ec)) << ec.message();
ASSERT_THAT(chown(dst.c_str(), 0, 0), SyscallSucceeds());
ASSERT_THAT(chmod(dst.c_str(), mode), SyscallSucceeds());
}
static void DropToOtherUser() {
ASSERT_THAT(setgroups(0, nullptr), SyscallSucceeds());
ASSERT_THAT(setresgid(kOtherGid, kOtherGid, kOtherGid), SyscallSucceeds());
ASSERT_THAT(setresuid(kOtherUid, kOtherUid, kOtherUid), SyscallSucceeds());
}
static constexpr unsigned int kOtherUid = 65534;
static constexpr unsigned int kOtherGid = 65534;
};
// Verify that access checks are made against the overlay permissions for the caller, but use the
// mounter credentials to check the underlying filesystems.
TEST_F(OverlayFsAccessTest, MounterAndOtherAccessChecks) {
ASSERT_NO_FATAL_FAILURE(MountWithReadableAndWritableFiles());
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
SAFE_SYSCALL(setgid(kOtherGid));
SAFE_SYSCALL(setuid(kOtherUid));
ASSERT_NE(getuid(), 0u);
// Other UID can read if it has access in the overlay, even if it could not read directly from
// `lower_`.
fbl::unique_fd fd(open((overlay_ + "/readable").c_str(), O_RDONLY));
EXPECT_THAT(fd.get(), SyscallSucceeds());
EXPECT_THAT(open((overlay_ + "/lower_readable").c_str(), O_RDONLY),
SyscallFailsWithErrno(EACCES));
fd.reset(open((overlay_ + "/upper_readable").c_str(), O_RDONLY));
EXPECT_THAT(fd.get(), SyscallSucceeds());
// Other UID can write if it has access in the overlay, even if it could not write directly via
// `lower_`.
fd.reset(open((overlay_ + "/writable").c_str(), O_WRONLY));
EXPECT_THAT(fd.get(), SyscallSucceeds());
EXPECT_THAT(open((overlay_ + "/lower_writable").c_str(), O_WRONLY),
SyscallFailsWithErrno(EACCES));
fd.reset(open((overlay_ + "/upper_writable").c_str(), O_WRONLY));
EXPECT_THAT(fd.get(), SyscallSucceeds());
// Other UID can create a new file, which should be owned by them.
fd.reset(open((overlay_ + "/new_file").c_str(), O_WRONLY | O_CREAT, 0666));
EXPECT_THAT(fd.get(), SyscallSucceeds());
});
ASSERT_TRUE(helper.WaitForChildren());
struct stat stats;
// The new file should be owned by the other UID.
ASSERT_THAT(stat((overlay_ + "/new_file").c_str(), &stats), SyscallSucceeds());
EXPECT_EQ(stats.st_uid, kOtherUid);
EXPECT_EQ(stats.st_gid, kOtherGid);
// Existing files that are copied-up should not change ownership.
ASSERT_THAT(stat((overlay_ + "/writable").c_str(), &stats), SyscallSucceeds());
EXPECT_EQ(stats.st_uid, 0u);
EXPECT_EQ(stats.st_gid, 0u);
}
// Verify that the `access()` API correctly reflects caller and mounter access check results.
TEST_F(OverlayFsAccessTest, LockedDownLowerAndWorkdirPermissions) {
ASSERT_NO_FATAL_FAILURE(MountWithReadableAndWritableFiles());
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
SAFE_SYSCALL(setgid(kOtherGid));
SAFE_SYSCALL(setuid(kOtherUid));
ASSERT_NE(getuid(), 0u);
// Other UID can read if it has access in the overlay, even if it could not read directly from
// `lower_`.
EXPECT_THAT(access((overlay_ + "/readable").c_str(), R_OK), SyscallSucceeds());
EXPECT_THAT(access((overlay_ + "/lower_readable").c_str(), R_OK),
SyscallFailsWithErrno(EACCES));
EXPECT_THAT(access((overlay_ + "/upper_readable").c_str(), R_OK), SyscallSucceeds());
// Other UID can write if it has access in the overlay, even if it could not write directly via
// `lower_`.
EXPECT_THAT(access((overlay_ + "/writable").c_str(), W_OK), SyscallSucceeds());
EXPECT_THAT(access((overlay_ + "/lower_writable").c_str(), W_OK),
SyscallFailsWithErrno(EACCES));
EXPECT_THAT(access((overlay_ + "/upper_writable").c_str(), W_OK), SyscallSucceeds());
});
ASSERT_TRUE(helper.WaitForChildren());
}
// Verify that `access(X_OK)` and `execve()` evaluate caller execute permissions against the
// active overlay node (upper if copied up, otherwise lower) while using mounter credentials
// to access the underlying lower/upper filesystems.
TEST_F(OverlayFsAccessTest, ExecutableAccessChecks) {
const std::string exit_zero_path = test_helper::GetTestResourcePath("exit_zero");
// Use `print_uid_gid_exec_child` (which exits `EXIT_FAILURE` when `kOutputFd` is closed) for
// files whose execution must fail, so an unexpected `execve()` success fails `WaitForChildren()`.
const std::string fail_if_execed_path =
test_helper::GetTestResourcePath("print_uid_gid_exec_child");
ASSERT_NO_FATAL_FAILURE(StageExecutable(exit_zero_path, lower_ + "/executable", 0755));
ASSERT_NO_FATAL_FAILURE(StageExecutable(fail_if_execed_path, lower_ + "/lower_executable", 0755));
ASSERT_NO_FATAL_FAILURE(StageExecutable(exit_zero_path, lower_ + "/upper_executable", 0600));
ASSERT_NO_FATAL_FAILURE(StageExecutable(fail_if_execed_path, lower_ + "/non_executable", 0644));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(chmod(overlay_.c_str(), 0777), SyscallSucceeds());
// Revoke non-owner execute permission in upper for `lower_executable` (keeping owner execute so
// the root mounter check still passes), and grant execute in upper for `upper_executable`.
ASSERT_THAT(chmod((overlay_ + "/lower_executable").c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/upper_executable").c_str(), 0755), SyscallSucceeds());
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
ASSERT_NO_FATAL_FAILURE(DropToOtherUser());
// Direct access to `lower_` fails because `lower_` has mode 0700 owned by root.
EXPECT_THAT(access((lower_ + "/executable").c_str(), X_OK), SyscallFailsWithErrno(EACCES));
EXPECT_THAT(access((overlay_ + "/executable").c_str(), X_OK), SyscallSucceeds());
EXPECT_THAT(access((overlay_ + "/lower_executable").c_str(), X_OK),
SyscallFailsWithErrno(EACCES));
EXPECT_THAT(access((overlay_ + "/upper_executable").c_str(), X_OK), SyscallSucceeds());
EXPECT_THAT(access((overlay_ + "/non_executable").c_str(), X_OK),
SyscallFailsWithErrno(EACCES));
std::string lower_exec_overlay = overlay_ + "/lower_executable";
char* const lower_argv[] = {const_cast<char*>(lower_exec_overlay.c_str()), nullptr};
EXPECT_THAT(execve(lower_exec_overlay.c_str(), lower_argv, nullptr),
SyscallFailsWithErrno(EACCES));
std::string non_exec_overlay = overlay_ + "/non_executable";
char* const non_exec_argv[] = {const_cast<char*>(non_exec_overlay.c_str()), nullptr};
EXPECT_THAT(execve(non_exec_overlay.c_str(), non_exec_argv, nullptr),
SyscallFailsWithErrno(EACCES));
});
ASSERT_TRUE(helper.WaitForChildren());
for (const char* name : {"/executable", "/upper_executable"}) {
std::string target = overlay_ + name;
helper.RunInForkedProcess([&] {
ASSERT_NO_FATAL_FAILURE(DropToOtherUser());
char* const argv[] = {const_cast<char*>(target.c_str()), nullptr};
ASSERT_THAT(execve(target.c_str(), argv, nullptr), SyscallSucceeds());
});
ASSERT_TRUE(helper.WaitForChildren());
}
}
// Verify SUID/SGID credential elevation and execute permission checks across lower and upper
// overlay layers.
// Regression test for https://fxbug.dev/508531124.
TEST_F(OverlayFsAccessTest, SuidAndSgidExecOnOverlay) {
constexpr int kOutputFd = 100;
const std::string creds_binary = test_helper::GetTestResourcePath("print_uid_gid_exec_child");
// 1. SUID/SGID binary residing only in `lower_` (which is 0700, inaccessible directly to
// `kOtherUid`).
ASSERT_NO_FATAL_FAILURE(
StageExecutable(creds_binary, lower_ + "/lower_suid", S_ISUID | S_ISGID | 0755));
// 2. Binary that is 0600 in `lower_`, promoted to `S_ISUID | S_ISGID | 0755` in `upper_`.
ASSERT_NO_FATAL_FAILURE(StageExecutable(creds_binary, lower_ + "/upper_suid", 0600));
// 3. Binary that is `S_ISUID | S_ISGID | 0755` in `lower_`, but has non-owner execute permission
// revoked in `upper_` (`S_ISUID | S_ISGID | 0700`).
ASSERT_NO_FATAL_FAILURE(
StageExecutable(creds_binary, lower_ + "/revoked_exec_suid", S_ISUID | S_ISGID | 0755));
// 4. Binary that is `S_ISUID | S_ISGID | 0755` in `lower_`, but has SUID/SGID cleared in
// `upper_` (`0755`).
ASSERT_NO_FATAL_FAILURE(
StageExecutable(creds_binary, lower_ + "/revoked_suid", S_ISUID | S_ISGID | 0755));
ASSERT_NO_FATAL_FAILURE(Mount());
ASSERT_THAT(chmod(overlay_.c_str(), 0777), SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/upper_suid").c_str(), S_ISUID | S_ISGID | 0755),
SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/revoked_exec_suid").c_str(), S_ISUID | S_ISGID | 0700),
SyscallSucceeds());
ASSERT_THAT(chmod((overlay_ + "/revoked_suid").c_str(), 0755), SyscallSucceeds());
auto run_and_expect_creds = [&](const std::string& rel_path, uid_t expected_euid,
gid_t expected_egid) {
SCOPED_TRACE(rel_path);
fbl::unique_fd fd(SAFE_SYSCALL(test_helper::MemFdCreate("creds", O_RDWR)));
ASSERT_TRUE(fd.is_valid());
std::string target = overlay_ + rel_path;
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
ASSERT_THAT(dup2(fd.get(), kOutputFd), SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(DropToOtherUser());
char* const argv[] = {const_cast<char*>(target.c_str()), nullptr};
ASSERT_THAT(execve(target.c_str(), argv, nullptr), SyscallSucceeds());
});
ASSERT_TRUE(helper.WaitForChildren());
ASSERT_THAT(lseek(fd.get(), 0, SEEK_SET), SyscallSucceeds());
std::string content;
ASSERT_TRUE(files::ReadFileDescriptorToString(fd.get(), &content));
uid_t ruid = 0, euid = 0, suid = 0;
gid_t rgid = 0, egid = 0, sgid = 0;
ASSERT_EQ(sscanf(content.c_str(), "ruid: %u euid: %u suid: %u\nrgid: %u egid: %u sgid: %u\n",
&ruid, &euid, &suid, &rgid, &egid, &sgid),
6)
<< "Unexpected credentials output: " << content;
EXPECT_EQ(ruid, kOtherUid);
EXPECT_EQ(euid, expected_euid);
EXPECT_EQ(suid, expected_euid);
EXPECT_EQ(rgid, kOtherGid);
EXPECT_EQ(egid, expected_egid);
EXPECT_EQ(sgid, expected_egid);
};
ASSERT_NO_FATAL_FAILURE(run_and_expect_creds("/lower_suid", 0, 0));
ASSERT_NO_FATAL_FAILURE(run_and_expect_creds("/upper_suid", 0, 0));
ASSERT_NO_FATAL_FAILURE(run_and_expect_creds("/revoked_suid", kOtherUid, kOtherGid));
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
ASSERT_NO_FATAL_FAILURE(DropToOtherUser());
std::string revoked_exec = overlay_ + "/revoked_exec_suid";
char* const argv[] = {const_cast<char*>(revoked_exec.c_str()), nullptr};
EXPECT_THAT(execve(revoked_exec.c_str(), argv, nullptr), SyscallFailsWithErrno(EACCES));
});
ASSERT_TRUE(helper.WaitForChildren());
}
} // namespace