hanzoai/visor
2
0
Fork 0
mirror of https://github.com/hanzoai/visor.git synced 2026-09-24 17:04:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
visor/test/syscalls/linux/mount.cc
T
Konstantin BogomolovandgVisor bot 58e263886b Implement /proc/sys/fs/mount-max. 
It's just a matter of exposing the option via sysfs. Capped to same max as
Linux, to follow convention of what we're already doing with nr_open.

PiperOrigin-RevId: 972901017
2026-08-28 19:02:13 -07:00

3424 lines
143 KiB
C++
Raw Permalink Blame History

// Copyright 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <errno.h>
#include <fcntl.h>
#include <linux/capability.h>
#include <linux/magic.h>
#include <sched.h>
#include <stdio.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/resource.h>
#include <sys/signalfd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include <sys/sysmacros.h>
#include <sys/un.h>
#include <sys/vfs.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <array>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <memory>
#include <ostream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/container/flat_hash_map.h"
#include "absl/strings/match.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "absl/strings/substitute.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "test/util/capability_util.h"
#include "test/util/cleanup.h"
#include "test/util/eventfd_util.h"
#include "test/util/file_descriptor.h"
#include "test/util/fs_util.h"
#include "test/util/linux_capability_util.h"
#include "test/util/logging.h"
#include "test/util/memory_util.h"
#include "test/util/mount_util.h"
#include "test/util/multiprocess_util.h"
#include "test/util/posix_error.h"
#include "test/util/save_util.h"
#include "test/util/temp_path.h"
#include "test/util/test_util.h"
#include "test/util/thread_util.h"
namespace gvisor {
namespace testing {
namespace {
using ::testing::AnyOf;
using ::testing::Contains;
using ::testing::IsSupersetOf;
using ::testing::Pair;
constexpr char kTmpfs[] = "tmpfs";
TEST(MountTest, MountBadFilesystem) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
// Linux expects a valid target before it checks the file system name.
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
EXPECT_THAT(mount("", dir.path().c_str(), "foobar", 0, ""),
SyscallFailsWithErrno(ENODEV));
}
TEST(MountTest, MountInvalidTarget) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = NewTempAbsPath();
EXPECT_THAT(mount("", dir.c_str(), kTmpfs, 0, ""),
SyscallFailsWithErrno(ENOENT));
}
TEST(MountTest, MountPermDenied) {
// Clear CAP_SYS_ADMIN.
AutoCapability cap(CAP_SYS_ADMIN, false);
// Linux expects a valid target before checking capability.
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
EXPECT_THAT(mount("", dir.path().c_str(), "", 0, ""),
SyscallFailsWithErrno(EPERM));
}
TEST(MountTest, UmountPermDenied) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
// Drop privileges in another thread, so we can still unmount the mounted
// directory.
ScopedThread([&]() {
EXPECT_NO_ERRNO(SetCapability(CAP_SYS_ADMIN, false));
EXPECT_THAT(umount(dir.path().c_str()), SyscallFailsWithErrno(EPERM));
});
}
TEST(MountTest, MountOverBusy) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
// Should be able to mount over a busy directory.
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
}
TEST(MountTest, OpenFileBusy) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "mode=0700", 0));
auto const fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
// An open file should prevent unmounting.
EXPECT_THAT(umount(dir.path().c_str()), SyscallFailsWithErrno(EBUSY));
}
TEST(MountTest, UmountNoFollow) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mountPoint = NewTempAbsPathInDir(dir.path());
ASSERT_THAT(mkdir(mountPoint.c_str(), 0777), SyscallSucceeds());
// Create a symlink in dir which will point to the actual mountpoint.
const std::string symlinkInDir = NewTempAbsPathInDir(dir.path());
EXPECT_THAT(symlink(mountPoint.c_str(), symlinkInDir.c_str()),
SyscallSucceeds());
// Create a symlink to the dir.
const std::string symlinkToDir = NewTempAbsPath();
EXPECT_THAT(symlink(dir.path().c_str(), symlinkToDir.c_str()),
SyscallSucceeds());
// Should fail with ELOOP when UMOUNT_NOFOLLOW is specified and the last
// component is a symlink.
auto mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", mountPoint, kTmpfs, 0, "mode=0700", 0));
EXPECT_THAT(umount2(symlinkInDir.c_str(), UMOUNT_NOFOLLOW),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(unlink(symlinkInDir.c_str()), SyscallSucceeds());
// UMOUNT_NOFOLLOW should only apply to the last path component. A symlink in
// non-last path component should be just fine.
EXPECT_THAT(umount2(JoinPath(symlinkToDir, Basename(mountPoint)).c_str(),
UMOUNT_NOFOLLOW),
SyscallSucceeds());
mount.Release();
}
TEST(MountTest, UmountDetach) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
// structure:
//
// dir (mount point)
// subdir
// file
//
// We show that we can walk around in the mount after detach-unmount dir.
//
// We show that even though dir is unreachable from outside the mount, we can
// still reach dir's (former) parent!
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const struct stat before = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
auto mount =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "mode=0700",
/* umountflags= */ MNT_DETACH));
const struct stat after = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
EXPECT_FALSE(before.st_dev == after.st_dev && before.st_ino == after.st_ino)
<< "mount point has device number " << before.st_dev
<< " and inode number " << before.st_ino << " before and after mount";
// Create files in the new mount.
constexpr char kContents[] = "no no no";
auto const subdir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
auto const file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), kContents, 0777));
auto const dir_fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(subdir.path(), O_RDONLY | O_DIRECTORY));
auto const fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDONLY));
// Unmount the tmpfs.
mount.Release()();
// Inode numbers for gofer-accessed files may change across save/restore.
//
// For overlayfs, if xino option is not enabled and if all overlayfs layers do
// not belong to the same filesystem then "the value of st_ino for directory
// objects may not be persistent and could change even while the overlay
// filesystem is mounted." -- Documentation/filesystems/overlayfs.txt
if (!IsRunningWithSaveRestore() &&
!ASSERT_NO_ERRNO_AND_VALUE(IsOverlayfs(dir.path()))) {
const struct stat after2 = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
EXPECT_EQ(before.st_ino, after2.st_ino);
}
// Can still read file after unmounting.
std::vector<char> buf(sizeof(kContents));
EXPECT_THAT(ReadFd(fd.get(), buf.data(), buf.size()), SyscallSucceeds());
// Walk to dir.
auto const mounted_dir = ASSERT_NO_ERRNO_AND_VALUE(
OpenAt(dir_fd.get(), "..", O_DIRECTORY | O_RDONLY));
// Walk to dir/file.
auto const fd_again = ASSERT_NO_ERRNO_AND_VALUE(
OpenAt(mounted_dir.get(), std::string(Basename(file.path())), O_RDONLY));
std::vector<char> buf2(sizeof(kContents));
EXPECT_THAT(ReadFd(fd_again.get(), buf2.data(), buf2.size()),
SyscallSucceeds());
EXPECT_EQ(buf, buf2);
// Walking outside the unmounted realm should still work, too!
auto const dir_parent = ASSERT_NO_ERRNO_AND_VALUE(
OpenAt(mounted_dir.get(), "..", O_DIRECTORY | O_RDONLY));
}
TEST(MountTest, MMapWithExecProtFailsOnNoExecFile) {
// Skips the test if test does not have needed capability to create the volume
// mount.
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto ret = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_NOEXEC, "", 0));
auto file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), "random1", 0777));
FileDescriptor fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path().c_str(), O_RDWR));
ASSERT_THAT(reinterpret_cast<uintptr_t>(
mmap(0, kPageSize, PROT_EXEC, MAP_PRIVATE, fd.get(), 0)),
SyscallFailsWithErrno(EPERM));
}
TEST(MountTest, MMapWithExecProtSucceedsOnExecutableVolumeFile) {
// Capability is needed to create tmpfs.
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto ret = ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
auto file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), "random1", 0777));
FileDescriptor fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path().c_str(), O_RDWR));
void* address = mmap(0, kPageSize, PROT_EXEC, MAP_PRIVATE, fd.get(), 0);
EXPECT_NE(address, MAP_FAILED);
MunmapSafe(address, kPageSize);
}
TEST(MountTest, MMapWithoutNoExecProtSucceedsOnNoExecFile) {
// Capability is needed to create tmpfs.
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto ret = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_NOEXEC, "", 0));
auto file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), "random1", 0777));
FileDescriptor fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path().c_str(), O_RDWR));
void* address =
mmap(0, kPageSize, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(), 0);
EXPECT_NE(address, MAP_FAILED);
MunmapSafe(address, kPageSize);
}
TEST(MountTest, MProtectWithNoExecProtFailsOnNoExecFile) {
// Capability is needed to create tmpfs.
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto ret = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_NOEXEC, "", 0));
auto file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), "random1", 0777));
FileDescriptor fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path().c_str(), O_RDWR));
void* address =
mmap(0, kPageSize, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(), 0);
EXPECT_NE(address, MAP_FAILED);
ASSERT_THAT(mprotect(address, kPageSize, PROT_EXEC),
SyscallFailsWithErrno(EACCES));
MunmapSafe(address, kPageSize);
}
TEST(MountTest, UmountMountsStackedOnDot) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
// Verify that unmounting at "." properly unmounts the mount at the top of
// mount stack.
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
TEST_CHECK_SUCCESS(chdir(dir.path().c_str()));
const struct stat before = ASSERT_NO_ERRNO_AND_VALUE(Stat("."));
TEST_CHECK_SUCCESS(mount("", dir.path().c_str(), kTmpfs, 0, "mode=0700"));
TEST_CHECK_SUCCESS(mount("", dir.path().c_str(), kTmpfs, 0, "mode=0700"));
// Unmount the second mount at "."
TEST_CHECK_SUCCESS(umount2(".", MNT_DETACH));
// Unmount the first mount at "."; this will fail if umount does not resolve
// "." to the topmost mount.
TEST_CHECK_SUCCESS(umount2(".", MNT_DETACH));
const struct stat after2 = ASSERT_NO_ERRNO_AND_VALUE(Stat("."));
EXPECT_TRUE(before.st_dev == after2.st_dev && before.st_ino == after2.st_ino);
}
TEST(MountTest, ActiveSubmountBusy) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount1 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "mode=0700", 0));
auto const dir2 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
auto const mount2 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir2.path(), kTmpfs, 0, "", 0));
// Since dir now has an active submount, should not be able to unmount.
EXPECT_THAT(umount(dir.path().c_str()), SyscallFailsWithErrno(EBUSY));
}
TEST(MountTest, MountTmpfs) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
// NOTE(b/129868551): Inode IDs are only stable across S/R if we have an open
// FD for that inode. Since we are going to compare inode IDs below, get a
// FileDescriptor for this directory here, which will be closed automatically
// at the end of the test.
auto const fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(dir.path(), O_DIRECTORY, O_RDONLY));
const struct stat before = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
{
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "mode=0700", 0));
const struct stat s = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
EXPECT_EQ(s.st_mode, S_IFDIR | 0700);
EXPECT_FALSE(before.st_dev == s.st_dev && before.st_ino == s.st_ino)
<< "mount point has device number " << before.st_dev
<< " and inode number " << before.st_ino << " before and after mount";
EXPECT_NO_ERRNO(Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
}
// Now that dir is unmounted again, we should have the old inode back.
//
// Inode numbers for gofer-accessed files may change across save/restore.
//
// For overlayfs, if xino option is not enabled and if all overlayfs layers do
// not belong to the same filesystem then "the value of st_ino for directory
// objects may not be persistent and could change even while the overlay
// filesystem is mounted." -- Documentation/filesystems/overlayfs.txt
if (!IsRunningWithSaveRestore() &&
!ASSERT_NO_ERRNO_AND_VALUE(IsOverlayfs(dir.path()))) {
const struct stat after = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
EXPECT_EQ(before.st_ino, after.st_ino);
}
}
TEST(MountTest, MountTmpfsMagicValIgnored) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_MGC_VAL, "mode=0700", 0));
}
// Passing nullptr to data is equivalent to "".
TEST(MountTest, NullData) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
EXPECT_THAT(mount("", dir.path().c_str(), kTmpfs, 0, nullptr),
SyscallSucceeds());
EXPECT_THAT(umount2(dir.path().c_str(), 0), SyscallSucceeds());
}
TEST(MountTest, MountReadonly) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_RDONLY, "mode=0777", 0));
const struct stat s = ASSERT_NO_ERRNO_AND_VALUE(Stat(dir.path()));
EXPECT_EQ(s.st_mode, S_IFDIR | 0777);
EXPECT_THAT(access(dir.path().c_str(), W_OK), SyscallFailsWithErrno(EROFS));
std::string const filename = JoinPath(dir.path(), "foo");
EXPECT_THAT(open(filename.c_str(), O_RDWR | O_CREAT, 0777),
SyscallFailsWithErrno(EROFS));
}
TEST(MountTest, BindMountReadonly) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const bindDir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir.path(), bindDir.path(), "", MS_BIND, "", 0));
std::string const filename = JoinPath(bindDir.path(), "foo");
FileDescriptor fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(filename, O_RDWR | O_CREAT, 0644));
char msg[] = "hello world";
EXPECT_THAT(pwrite64(fd.get(), msg, strlen(msg), 0),
SyscallSucceedsWithValue(strlen(msg)));
fd.reset();
EXPECT_THAT(mount(dir.path().c_str(), bindDir.path().c_str(), NULL,
MS_BIND | MS_RDONLY | MS_REMOUNT, NULL),
SyscallSucceeds());
EXPECT_THAT(access(bindDir.path().c_str(), W_OK),
SyscallFailsWithErrno(EROFS));
EXPECT_THAT(open(filename.c_str(), O_RDWR), SyscallFailsWithErrno(EROFS));
EXPECT_THAT(open(filename.c_str(), O_RDWR | O_TRUNC),
SyscallFailsWithErrno(EROFS));
EXPECT_THAT(open(filename.c_str(), O_RDONLY | O_TRUNC),
SyscallFailsWithErrno(EROFS));
const struct stat s = ASSERT_NO_ERRNO_AND_VALUE(Stat(filename));
EXPECT_EQ(s.st_size, strlen(msg));
}
// Special files (such as FIFO) should be openable for writing even on a
// read-only mount. Regular files should not.
TEST(MountTest, FifoWritableOnReadonlyMount) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
// Populate the still-writable mount with a FIFO and a regular file.
std::string const fifo_path = JoinPath(dir.path(), "fifo");
std::string const reg_path = JoinPath(dir.path(), "reg");
ASSERT_THAT(mkfifo(fifo_path.c_str(), 0666), SyscallSucceeds());
FileDescriptor reg_fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(reg_path, O_WRONLY | O_CREAT, 0644));
reg_fd.reset();
// Remount read-only.
ASSERT_THAT(
mount("", dir.path().c_str(), nullptr, MS_REMOUNT | MS_RDONLY, nullptr),
SyscallSucceeds());
ASSERT_THAT(access(dir.path().c_str(), W_OK), SyscallFailsWithErrno(EROFS));
// The FIFO opens writably despite the RO mount.
FileDescriptor fifo_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(fifo_path, O_RDWR));
EXPECT_THAT(write(fifo_fd.get(), "x", 1), SyscallSucceedsWithValue(1));
// The regular file still fails a writable open with EROFS, but a read-only
// open succeeds.
EXPECT_THAT(open(reg_path.c_str(), O_WRONLY), SyscallFailsWithErrno(EROFS));
ASSERT_NO_ERRNO_AND_VALUE(Open(reg_path, O_RDONLY));
}
// Same test as above, but for a character device.
TEST(MountTest, DeviceFileWritableOnReadonlyMount) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
// Create a /dev/null-style character device while the mount is writable.
std::string const dev_path = JoinPath(dir.path(), "null");
int ret = mknod(dev_path.c_str(), S_IFCHR | 0666, makedev(1, 3));
const bool was_eperm = Value(ret, SyscallFailsWithErrno(EPERM));
// In our test infrastructure, this may not always be possible to test on
// native since CAP_MKNOD is required in the *initial* user ns, and native
// tests are sometimes run in a user ns.
SKIP_IF(was_eperm);
// (But otherwise, mknod() should succeed.)
ASSERT_THAT(ret, SyscallSucceeds());
// Remount read-only.
ASSERT_THAT(
mount("", dir.path().c_str(), nullptr, MS_REMOUNT | MS_RDONLY, nullptr),
SyscallSucceeds());
// The device node opens writably and accepts writes despite the RO mount.
FileDescriptor dev_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(dev_path, O_WRONLY));
EXPECT_THAT(write(dev_fd.get(), "x", 1), SyscallSucceedsWithValue(1));
}
TEST(MountTest, ReadOnlyBindMountAllowsWriteOpenOfCharDevice) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
std::string const nullPath = JoinPath(dir.path(), "null");
FileDescriptor create_fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(nullPath, O_CREAT | O_RDWR, 0666));
create_fd.reset();
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("/dev/null", nullPath, "", MS_BIND, "", 0));
ASSERT_THAT(mount("/dev/null", nullPath.c_str(), nullptr,
MS_BIND | MS_REMOUNT | MS_RDONLY, nullptr),
SyscallSucceeds());
FileDescriptor wfd = ASSERT_NO_ERRNO_AND_VALUE(Open(nullPath, O_WRONLY));
char msg[] = "hello";
EXPECT_THAT(write(wfd.get(), msg, sizeof(msg)),
SyscallSucceedsWithValue(sizeof(msg)));
FileDescriptor rwfd = ASSERT_NO_ERRNO_AND_VALUE(Open(nullPath, O_RDWR));
EXPECT_THAT(write(rwfd.get(), msg, sizeof(msg)),
SyscallSucceedsWithValue(sizeof(msg)));
}
TEST(MountTest, ReadOnlyBindMountAllowsWriteOpenOfFIFO) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
std::string const fifoPath = JoinPath(dir.path(), "fifo");
ASSERT_THAT(mkfifo(fifoPath.c_str(), 0666), SyscallSucceeds());
auto const bindDir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir.path(), bindDir.path(), "", MS_BIND, "", 0));
ASSERT_THAT(mount(dir.path().c_str(), bindDir.path().c_str(), nullptr,
MS_BIND | MS_REMOUNT | MS_RDONLY, nullptr),
SyscallSucceeds());
std::string const boundFifoPath = JoinPath(bindDir.path(), "fifo");
FileDescriptor rfd =
ASSERT_NO_ERRNO_AND_VALUE(Open(boundFifoPath, O_RDONLY | O_NONBLOCK));
FileDescriptor wfd =
ASSERT_NO_ERRNO_AND_VALUE(Open(boundFifoPath, O_WRONLY | O_NONBLOCK));
char msg[] = "hello";
EXPECT_THAT(write(wfd.get(), msg, sizeof(msg)),
SyscallSucceedsWithValue(sizeof(msg)));
}
// Test that bind mounting a directory onto a regular file fails with ENOTDIR.
TEST(MountTest, BindMountDirectoryOntoFileFails) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const source_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
auto const target_file =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path()));
// Bind mounting a directory onto a file should fail with ENOTDIR.
EXPECT_THAT(mount(source_dir.path().c_str(), target_file.path().c_str(),
nullptr, MS_BIND, nullptr),
SyscallFailsWithErrno(ENOTDIR));
}
// Test that bind mounting a regular file onto a directory fails with ENOTDIR.
TEST(MountTest, BindMountFileOntoDirectoryFails) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const source_file =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path()));
auto const target_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
// Bind mounting a file onto a directory should fail with ENOTDIR.
EXPECT_THAT(mount(source_file.path().c_str(), target_dir.path().c_str(),
nullptr, MS_BIND, nullptr),
SyscallFailsWithErrno(ENOTDIR));
}
PosixErrorOr<absl::Time> ATime(absl::string_view file) {
struct stat s = {};
if (stat(std::string(file).c_str(), &s) == -1) {
return PosixError(errno, "stat failed");
}
return absl::TimeFromTimespec(s.st_atim);
}
TEST(MountTest, MountNoAtime) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_NOATIME, "mode=0777", 0));
std::string const contents = "No no no, don't follow the instructions!";
auto const file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), contents, 0777));
absl::Time const before = ASSERT_NO_ERRNO_AND_VALUE(ATime(file.path()));
// Reading from the file should change the atime, but the MS_NOATIME flag
// should prevent that.
auto const fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR));
char buf[100];
int read_n;
ASSERT_THAT(read_n = read(fd.get(), buf, sizeof(buf)), SyscallSucceeds());
EXPECT_EQ(std::string(buf, read_n), contents);
absl::Time const after = ASSERT_NO_ERRNO_AND_VALUE(ATime(file.path()));
// Expect that atime hasn't changed.
EXPECT_EQ(before, after);
}
TEST(MountTest, MountWithStrictAtime) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(Mount(
"", dir.path(), kTmpfs, MS_NOATIME | MS_STRICTATIME, "mode=0777", 0));
std::string const contents = "No no no, don't follow the instructions!";
auto const file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), contents, 0777));
absl::Time const before = ASSERT_NO_ERRNO_AND_VALUE(ATime(file.path()));
absl::SleepFor(absl::Milliseconds(100));
// MS_STRICTATIME should override MS_NOATIME and update the file's atime.
auto const fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR));
char buf[100];
int read_n;
ASSERT_THAT(read_n = read(fd.get(), buf, sizeof(buf)), SyscallSucceeds());
EXPECT_EQ(std::string(buf, read_n), contents);
absl::Time const after = ASSERT_NO_ERRNO_AND_VALUE(ATime(file.path()));
// The after atime is expected to be larger than the before atime.
EXPECT_LT(before, after);
}
TEST(MountTest, MountNoExec) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_NOEXEC, "mode=0777", 0));
std::string const contents = "No no no, don't follow the instructions!";
auto const file = ASSERT_NO_ERRNO_AND_VALUE(
TempPath::CreateFileWith(dir.path(), contents, 0777));
int execve_errno;
ASSERT_NO_ERRNO_AND_VALUE(
ForkAndExec(file.path(), {}, {}, nullptr, &execve_errno));
EXPECT_EQ(execve_errno, EACCES);
}
TEST(MountTest, RenameRemoveMountPoint) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir_parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir_parent.path()));
auto const new_dir = NewTempAbsPath();
auto const mount =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(rename(dir.path().c_str(), new_dir.c_str()),
SyscallFailsWithErrno(EBUSY));
ASSERT_THAT(rmdir(dir.path().c_str()), SyscallFailsWithErrno(EBUSY));
}
TEST(MountTest, MountMoveSuccess) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const privateParent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto privateMount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("source", privateParent.path(), kTmpfs, 0, "", 0));
EXPECT_THAT(mount("", privateParent.path().c_str(), "", MS_PRIVATE, ""),
SyscallSucceeds());
auto const dir1 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(privateParent.path()));
auto const dir2 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(privateParent.path()));
auto mount1 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("source", dir1.path(), kTmpfs, 0, "", 0));
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir1.path(), "foo").c_str(), O_CREAT | O_RDWR, 0777));
EXPECT_THAT(close(fd.release()), SyscallSucceeds());
auto const mount2 = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir1.path(), dir2.path(), "", MS_MOVE, "", 0));
mount1.Release();
EXPECT_THAT(Exists(JoinPath(dir1.path(), "foo")),
IsPosixErrorOkAndHolds(false));
EXPECT_THAT(Exists(JoinPath(dir2.path(), "foo")),
IsPosixErrorOkAndHolds(true));
}
// TODO(b/305893463): When support for MS_UNBINDABLE is added, moving a mount
// tree with unbindable children to an MS_SHARED destination should EINVAL.
TEST(MountTest, MountMoveSharedParent) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const parentDir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto parentMount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("source", parentDir1.path(), kTmpfs, 0, "", 0));
EXPECT_THAT(mount("", parentDir1.path().c_str(), "", MS_SHARED, ""),
SyscallSucceeds());
auto const subDir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parentDir1.path()));
auto subMount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("source", subDir.path(), kTmpfs, 0, "", 0));
EXPECT_THAT(
mount(subDir.path().c_str(), dir2.path().c_str(), "", MS_MOVE, nullptr),
SyscallFailsWithErrno(EINVAL));
}
TEST(MountTest, MountMoveSourceNotMounted) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir1.path(), "foo").c_str(), O_CREAT | O_RDWR, 0777));
EXPECT_THAT(close(fd.release()), SyscallSucceeds());
EXPECT_THAT(mount(dir1.path().c_str(), dir2.path().c_str(), "", MS_MOVE, ""),
SyscallFailsWithErrno(EINVAL));
}
TEST(MountTest, MountInfo) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, MS_NOEXEC, "mode=0123", 0));
const std::vector<ProcMountsEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountsEntries());
for (const auto& e : mounts) {
if (e.mount_point == dir.path()) {
EXPECT_EQ(e.fstype, kTmpfs);
auto mopts = ParseMountOptions(e.mount_opts);
EXPECT_THAT(mopts, AnyOf(Contains(Pair("mode", "0123")),
Contains(Pair("mode", "123"))));
}
}
const std::vector<ProcMountInfoEntry> mountinfo =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
for (auto const& e : mountinfo) {
if (e.mount_point == dir.path()) {
EXPECT_EQ(e.fstype, kTmpfs);
auto mopts = ParseMountOptions(e.super_opts);
EXPECT_THAT(mopts, AnyOf(Contains(Pair("mode", "0123")),
Contains(Pair("mode", "123"))));
}
}
}
TEST(MountTest, MountFlagsShownInProcMounts) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs,
MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, "", 0));
// The per-mount flags must be reflected in both /proc/self/mounts and
// /proc/self/mountinfo: userspace (e.g. systemd) reads them back to
// preserve locked flags across bind-remounts in user namespaces.
bool found_mounts = false;
const std::vector<ProcMountsEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountsEntries());
for (const auto& e : mounts) {
if (e.mount_point != dir.path()) continue;
found_mounts = true;
auto mopts = ParseMountOptions(e.mount_opts);
EXPECT_THAT(mopts, IsSupersetOf({Pair("nosuid", ""), Pair("nodev", ""),
Pair("noexec", ""), Pair("noatime", "")}))
<< "/proc/self/mounts options: " << e.mount_opts;
}
EXPECT_TRUE(found_mounts);
bool found_mountinfo = false;
const std::vector<ProcMountInfoEntry> mountinfo =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
for (auto const& e : mountinfo) {
if (e.mount_point != dir.path()) continue;
found_mountinfo = true;
auto mopts = ParseMountOptions(e.mount_opts);
EXPECT_THAT(mopts, IsSupersetOf({Pair("nosuid", ""), Pair("nodev", ""),
Pair("noexec", ""), Pair("noatime", "")}))
<< "/proc/self/mountinfo options: " << e.mount_opts;
}
EXPECT_TRUE(found_mountinfo);
}
TEST(MountTest, TmpfsSizeRoundUpSinglePageSize) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize / 2);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
// Check that it starts at size zero.
struct stat buf;
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 0);
// Grow to 1 Page Size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
// Grow to size beyond tmpfs allocated bytes.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize + 1),
SyscallFailsWithErrno(ENOSPC));
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
}
TEST(MountTest, TmpfsNrBlocksAllocation) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "nr_blocks=1", 0));
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
// Check that it starts at size zero.
struct stat buf;
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 0);
// Grow to 1 Page Size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
// Grow to size beyond the block limit.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize + 1),
SyscallFailsWithErrno(ENOSPC));
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
}
TEST(MountTest, TmpfsSizeAllocationMultiplePages) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto page_multiple = 2;
auto size = kPageSize * page_multiple;
auto tmpfs_size_opt = absl::StrCat("size=", size);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
// Check that it starts at size zero.
struct stat buf;
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 0);
// Ensure fallocate does not allow partial allocations.
ASSERT_THAT(fallocate(fd.get(), 0, 0, size + 1),
SyscallFailsWithErrno(ENOSPC));
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 0);
// Grow to multiple of page size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, size), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, size);
// Grow to beyond tmpfs size bytes.
ASSERT_THAT(fallocate(fd.get(), 0, 0, size + 1),
SyscallFailsWithErrno(ENOSPC));
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, size);
}
TEST(MountTest, TmpfsSizeMoreThanSinglePgSZMultipleFiles) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const page_multiple = 10;
auto const size = kPageSize * page_multiple;
auto tmpfs_size_opt = absl::StrCat("size=", size);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
for (int i = 0; i < page_multiple; i++) {
auto fd = ASSERT_NO_ERRNO_AND_VALUE(Open(
JoinPath(dir.path(), absl::StrCat("foo_", i)), O_CREAT | O_RDWR, 0777));
// Create buffer & Grow to 100 bytes.
struct stat buf;
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
ASSERT_THAT(fallocate(fd.get(), 0, 0, 100), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 100);
}
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), absl::StrCat("foo_", page_multiple + 1)),
O_CREAT | O_RDWR, 0777));
// Grow to beyond tmpfs size bytes after exhausting the size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize),
SyscallFailsWithErrno(ENOSPC));
}
TEST(MountTest, TmpfsSizeFtruncate) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir.path(), "foo"), O_CREAT | O_RDWR, 0777));
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
struct stat status;
ASSERT_THAT(fstat(fd.get(), &status), SyscallSucceeds());
EXPECT_EQ(status.st_size, kPageSize);
ASSERT_THAT(ftruncate(fd.get(), kPageSize + 1), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &status), SyscallSucceeds());
EXPECT_EQ(status.st_size, kPageSize + 1);
ASSERT_THAT(ftruncate(fd.get(), 0), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &status), SyscallSucceeds());
EXPECT_EQ(status.st_size, 0);
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &status), SyscallSucceeds());
EXPECT_EQ(status.st_size, kPageSize);
}
// Test shows directory does not take up any pages.
TEST(MountTest, TmpfsDirectoryAllocCheck) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir_parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir_parent.path(), kTmpfs, 0, tmpfs_size_opt, 0));
auto const dir_tmp =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir_parent.path()));
// Creating only 1 regular file allocates 1 page size.
auto fd = ASSERT_NO_ERRNO_AND_VALUE(
Open(JoinPath(dir_parent.path(), "foo"), O_CREAT | O_RDWR, 0777));
// Check that it starts at size zero.
struct stat buf;
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 0);
// Grow to 1 Page Size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
// Grow to beyond 1 Page Size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize + 1),
SyscallFailsWithErrno(ENOSPC));
}
// Tests memory allocation for symlinks.
TEST(MountTest, TmpfsSymlinkAllocCheck) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir_parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir_parent.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const int target_size = 128;
auto target = std::string(target_size - 1, 'a');
auto pathname = JoinPath(dir_parent.path(), "foo1");
EXPECT_THAT(symlink(target.c_str(), pathname.c_str()), SyscallSucceeds());
target = std::string(target_size, 'a');
pathname = absl::StrCat(dir_parent.path(), "/foo2");
EXPECT_THAT(symlink(target.c_str(), pathname.c_str()), SyscallSucceeds());
target = std::string(target_size, 'a');
pathname = absl::StrCat(dir_parent.path(), "/foo3");
EXPECT_THAT(symlink(target.c_str(), pathname.c_str()),
SyscallFailsWithErrno(ENOSPC));
target = std::string(target_size - 1, 'a');
pathname = absl::StrCat(dir_parent.path(), "/foo4");
EXPECT_THAT(symlink(target.c_str(), pathname.c_str()), SyscallSucceeds());
EXPECT_THAT(unlink(pathname.c_str()), SyscallSucceeds());
}
// Tests memory unallocation for symlinks.
TEST(MountTest, TmpfsSymlinkUnallocCheck) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir_parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir_parent.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const int target_size = 128;
auto pathname = JoinPath(dir_parent.path(), "foo1");
auto target = std::string(target_size, 'a');
EXPECT_THAT(symlink(target.c_str(), pathname.c_str()), SyscallSucceeds());
auto const fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(pathname, O_CREAT | O_RDWR, 0777));
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize),
SyscallFailsWithErrno(ENOSPC));
EXPECT_THAT(unlink(pathname.c_str()), SyscallSucceeds());
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
}
// Tests memory allocation for Hard Links is not double allocated.
TEST(MountTest, TmpfsHardLinkAllocCheck) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const std::string fileOne = JoinPath(dir.path(), "foo1");
const std::string fileTwo = JoinPath(dir.path(), "foo2");
auto const fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(fileOne, O_CREAT | O_RDWR, 0777));
EXPECT_THAT(link(fileOne.c_str(), fileTwo.c_str()), SyscallSucceeds());
// Check that it starts at size zero.
struct stat buf;
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, 0);
// Grow to 1 Page Size.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize), SyscallSucceeds());
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
// Grow to size beyond tmpfs allocated bytes.
ASSERT_THAT(fallocate(fd.get(), 0, 0, kPageSize + 1),
SyscallFailsWithErrno(ENOSPC));
ASSERT_THAT(fstat(fd.get(), &buf), SyscallSucceeds());
EXPECT_EQ(buf.st_size, kPageSize);
EXPECT_THAT(unlink(fileTwo.c_str()), SyscallSucceeds());
EXPECT_THAT(unlink(fileOne.c_str()), SyscallSucceeds());
}
// Tests memory allocation for empty size.
TEST(MountTest, TmpfsEmptySizeAllocCheck) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount("", dir.path().c_str(), kTmpfs, 0, "size"),
SyscallFailsWithErrno(EINVAL));
}
TEST(MountTest, TmpfsUnlinkRegularFileAllocCheck) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
const int kTruncateSize = 2 * kPageSize;
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const std::string fileOne = JoinPath(dir.path(), "foo1");
auto fd = ASSERT_NO_ERRNO_AND_VALUE(Open(fileOne, O_CREAT | O_RDWR, 0777));
EXPECT_THAT(unlink(fileOne.c_str()), SyscallSucceeds());
EXPECT_THAT(ftruncate(fd.get(), kTruncateSize), SyscallSucceeds());
}
TEST(MountTest, TmpfsSizePartialWriteSinglePage) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const std::string fileOne = JoinPath(dir.path(), "foo1");
auto fd = ASSERT_NO_ERRNO_AND_VALUE(Open(fileOne, O_CREAT | O_RDWR, 0777));
lseek(fd.get(), kPageSize - 2, SEEK_SET);
char buf[4];
EXPECT_THAT(write(fd.get(), buf, 4), SyscallSucceedsWithValue(2));
EXPECT_THAT(write(fd.get(), buf, 4), SyscallFailsWithErrno(ENOSPC));
}
TEST(MountTest, TmpfsSizePartialWriteMultiplePages) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", 3 * kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const std::string fileOne = JoinPath(dir.path(), "foo1");
auto fd = ASSERT_NO_ERRNO_AND_VALUE(Open(fileOne, O_CREAT | O_RDWR, 0777));
lseek(fd.get(), kPageSize, SEEK_SET);
std::vector<char> buf(kPageSize + 2);
EXPECT_THAT(write(fd.get(), buf.data(), 4), SyscallSucceedsWithValue(4));
struct stat status;
ASSERT_THAT(fstat(fd.get(), &status), SyscallSucceeds());
EXPECT_EQ(status.st_size, kPageSize + 4);
EXPECT_THAT(write(fd.get(), buf.data(), 1), SyscallSucceedsWithValue(1));
// Writing with size exactly until the end of page boundary.
EXPECT_THAT(write(fd.get(), buf.data(), kPageSize - 5),
SyscallSucceedsWithValue(kPageSize - 5));
EXPECT_THAT(write(fd.get(), buf.data(), 1), SyscallSucceedsWithValue(1));
// Writing with size more than page end & having extra page available as well.
EXPECT_THAT(write(fd.get(), buf.data(), kPageSize + 1),
SyscallSucceedsWithValue(kPageSize + 1));
// Writing with size more than page end & having no page available.
EXPECT_THAT(write(fd.get(), buf.data(), kPageSize + 1),
SyscallSucceedsWithValue(kPageSize - 2));
EXPECT_THAT(write(fd.get(), buf.data(), 1), SyscallFailsWithErrno(ENOSPC));
}
TEST(MountTest, TmpfsSizeMmap) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto tmpfs_size_opt = absl::StrCat("size=", kPageSize);
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, tmpfs_size_opt, 0));
const std::string fileOne = JoinPath(dir.path(), "foo");
auto fd = ASSERT_NO_ERRNO_AND_VALUE(Open(fileOne, O_CREAT | O_RDWR, 0777));
EXPECT_THAT(ftruncate(fd.get(), 2 * kPageSize), SyscallSucceeds());
void* addr = mmap(NULL, 2 * kPageSize, PROT_READ, MAP_PRIVATE, fd.get(), 0);
EXPECT_NE(addr, MAP_FAILED);
// Access memory so that the first page to page fault occurs and is allocated.
char data = ((char*)addr)[kPageSize - 2];
EXPECT_EQ(data, 0);
std::vector<char> in(kPageSize + 2);
// Access memory such that it causes the second page to page fault. The page
// fault should fail due to hitting tmpfs size limit which should cause
// SIGBUS signal.
EXPECT_EXIT(memcpy(in.data(), reinterpret_cast<char*>(addr), kPageSize + 2),
::testing::KilledBySignal(SIGBUS), "");
EXPECT_THAT(munmap(addr, 2 * kPageSize), SyscallSucceeds());
}
TEST(MountTest, SimpleBind) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path(), kTmpfs, 0, "mode=0123", 0));
auto const child1 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const child2 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const bind_mount = Mount(dir1.path(), dir2.path(), "", MS_BIND, "", 0);
// Write to child1 in dir1.
const std::string filename = "foo.txt";
const std::string contents = "barbaz";
ASSERT_NO_ERRNO(
CreateWithContents(JoinPath(child1.path(), filename), contents, 0666));
// Verify both directories have the same nodes.
std::vector<std::string> child_names = {std::string(Basename(child1.path())),
std::string(Basename(child2.path()))};
ASSERT_NO_ERRNO(DirContains(dir1.path(), child_names, {}));
ASSERT_NO_ERRNO(DirContains(dir2.path(), child_names, {}));
const std::string dir1_filepath =
JoinPath(dir1.path(), Basename(child1.path()), filename);
const std::string dir2_filepath =
JoinPath(dir2.path(), Basename(child1.path()), filename);
std::string output;
ASSERT_NO_ERRNO(GetContents(dir1_filepath, &output));
EXPECT_EQ(output, contents);
ASSERT_NO_ERRNO(GetContents(dir2_filepath, &output));
EXPECT_EQ(output, contents);
}
TEST(MountTest, BindToSelf) {
// Test that we can turn a normal directory into a mount with MS_BIND.
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const std::vector<ProcMountsEntry> mounts_before =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountsEntries());
for (const auto& e : mounts_before) {
ASSERT_NE(e.mount_point, dir.path());
}
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir.path(), dir.path(), "", MS_BIND, "", 0));
const std::vector<ProcMountsEntry> mounts_after =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountsEntries());
bool found = false;
for (const auto& e : mounts_after) {
if (e.mount_point == dir.path()) {
found = true;
}
}
ASSERT_TRUE(found);
}
TEST(MountTest, MaxMounts) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount("", parent.path().c_str(), kTmpfs, 0, ""),
SyscallSucceeds());
auto const dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
ASSERT_THAT(
mount(dir.path().c_str(), dir.path().c_str(), nullptr, MS_BIND, nullptr),
SyscallSucceeds());
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_SHARED, ""),
SyscallSucceeds());
// Each bind mount doubles the number of mounts in the peer group. The number
// of binds we can do before failing is log2(max_mounts-num_current_mounts).
int mount_max = 10000;
bool mount_max_exists =
ASSERT_NO_ERRNO_AND_VALUE(Exists("/proc/sys/fs/mount-max"));
if (mount_max_exists) {
std::string mount_max_string;
ASSERT_NO_ERRNO(GetContents("/proc/sys/fs/mount-max", &mount_max_string));
ASSERT_TRUE(absl::SimpleAtoi(mount_max_string, &mount_max));
}
const std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
int num_binds = static_cast<int>(std::log2(mount_max - mounts.size()));
for (int i = 0; i < num_binds; i++) {
ASSERT_THAT(mount(dir.path().c_str(), dir.path().c_str(), nullptr, MS_BIND,
nullptr),
SyscallSucceeds());
}
ASSERT_THAT(
mount(dir.path().c_str(), dir.path().c_str(), nullptr, MS_BIND, nullptr),
SyscallFailsWithErrno(ENOSPC));
umount2(parent.path().c_str(), MNT_DETACH);
}
TEST(MountTest, PropagateToSameMountpointStacksMounts) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir.path().c_str(), dir.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const child =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
ASSERT_THAT(mount(child.path().c_str(), child.path().c_str(), "", MS_BIND, 0),
SyscallSucceeds());
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
std::string dir2_child_path = JoinPath(dir2.path(), Basename(child.path()));
ASSERT_THAT(
mount(dir2_child_path.c_str(), dir2_child_path.c_str(), "", MS_BIND, 0),
SyscallSucceeds());
// Check that mounts at the child mount point have distinct parents.
std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
uint64_t parent_id = 0;
for (auto& minfo : mounts) {
if (minfo.mount_point == child.path()) {
if (parent_id == 0) {
parent_id = minfo.parent_id;
} else {
EXPECT_NE(parent_id, minfo.parent_id);
}
}
}
}
TEST(MountTest, UmountReparentsCoveredMounts) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const child =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
ASSERT_THAT(mount("", child.path().c_str(), kTmpfs, 0, 0), SyscallSucceeds());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
std::string dir2_child_path = JoinPath(dir2.path(), Basename(child.path()));
ASSERT_THAT(mount("", dir2_child_path.c_str(), kTmpfs, 0, 0),
SyscallSucceeds());
umount2(dir2_child_path.c_str(), MNT_DETACH);
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[child.path()].empty());
EXPECT_NE(optionals[child.path()][0].shared, 0);
EXPECT_TRUE(optionals[dir2_child_path].empty());
}
// Tests that it is possible to make a shared mount.
TEST(MountTest, MakeShared) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path().c_str(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir.path()].empty());
EXPECT_NE(optionals[dir.path()][0].shared, 0);
}
// Tests that shared mounts have different group IDs.
TEST(MountTest, MakeMultipleShared) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount1 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir1.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount2 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir2.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir2.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
EXPECT_NE(optionals[dir1.path()][0].shared, optionals[dir2.path()][0].shared);
}
// Tests that shared mounts reused group IDs from deleted groups.
TEST(MountTest, ReuseGroupIDs) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount1 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir1.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
int reused_group_id;
{
auto const mount2 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir2.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir2.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir2.path()].empty());
reused_group_id = optionals[dir2.path()][0].shared;
}
// Check that created a new shared mount reuses the ID 2.
auto const mount2 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir2.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir2.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir2.path()].empty());
EXPECT_EQ(reused_group_id, optionals[dir2.path()][0].shared);
}
// Tests that a child mount inherits the propagation type of its parent.
TEST(MountTest, InerheritPropagation) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount1 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir1.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const mount2 =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir2.path(), kTmpfs, 0, "", 0));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir2.path()].empty());
EXPECT_NE(optionals[dir2.path()][0].shared, 0);
}
// Tests that it is possible to make a mount private again after it is shared.
TEST(MountTest, MakePrivate) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_PRIVATE, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir.path()].empty());
EXPECT_EQ(optionals[dir.path()][0].shared, 0);
}
TEST(MountTest, ArgumentsAreIgnored) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
// These mounts should not fail even though string arguments are passed as
// NULL.
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir.path(), dir.path(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(NULL, dir.path().c_str(), NULL, MS_SHARED, NULL),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir.path()].empty());
EXPECT_NE(optionals[dir.path()][0].shared, 0);
}
TEST(MountTest, MultiplePropagationFlagsFails) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
EXPECT_THAT(mount("", dir.path().c_str(), "", MS_SHARED | MS_PRIVATE, 0),
SyscallFailsWithErrno(EINVAL));
}
TEST(MountTest, SetMountPropagationOfStackedMounts) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path().c_str(), kTmpfs, 0, "", 0));
// Only the topmost mount on the stack should be shared.
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path().c_str(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir.path()].empty());
EXPECT_EQ(optionals[dir.path()][0].shared, 0);
EXPECT_NE(optionals[dir.path()][1].shared, 0);
}
TEST(MountTest, MakePeer) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path().c_str(), kTmpfs, 0, "", 0));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir1.path(), dir2.path(), "", MS_BIND, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
EXPECT_EQ(optionals[dir1.path()][0].shared, optionals[dir2.path()][0].shared);
EXPECT_NE(optionals[dir1.path()][0].shared, 0);
}
TEST(MountTest, PropagateMountEvent) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
auto const child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir1.path(), dir2.path(), "", MS_BIND, "", MNT_DETACH));
// This mount should propagate to dir2.
auto const child_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", child_dir.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
const std::string child_path1 =
JoinPath(dir1.path(), Basename(child_dir.path()));
const std::string child_path2 =
JoinPath(dir2.path(), Basename(child_dir.path()));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
ASSERT_FALSE(optionals[child_path1].empty());
ASSERT_FALSE(optionals[child_path2].empty());
EXPECT_EQ(optionals[dir1.path()][0].shared, optionals[dir2.path()][0].shared);
EXPECT_NE(optionals[dir1.path()][0].shared, 0);
EXPECT_EQ(optionals[child_path1][0].shared, optionals[child_path2][0].shared);
EXPECT_NE(optionals[child_path1][0].shared, 0);
}
TEST(MountTest, PropagateUmountEvent) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
auto const child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir1.path(), dir2.path(), "", MS_BIND, "", MNT_DETACH));
// This mount will propagate to dir2. Once the block ends it will be
// unmounted, which should also propagate to dir2.
{
auto const child_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", child_dir.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
}
const std::string child_path1 =
JoinPath(dir1.path(), Basename(child_dir.path()));
const std::string child_path2 =
JoinPath(dir2.path(), Basename(child_dir.path()));
std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
for (const auto& e : mounts) {
EXPECT_NE(e.mount_point, child_path1);
EXPECT_NE(e.mount_point, child_path2);
}
}
TEST(MountTest, PropagateChildUmountEvent) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
TempPath const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount("", dir1.path().c_str(), kTmpfs, 0, ""), SyscallSucceeds());
TempPath const child =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
ASSERT_THAT(mount("", child.path().c_str(), kTmpfs, 0, ""),
SyscallSucceeds());
ASSERT_THAT(mount("", child.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
TempPath const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount(child.path().c_str(), dir2.path().c_str(), "", MS_BIND, 0),
SyscallSucceeds());
ASSERT_THAT(mount("", child.path().c_str(), kTmpfs, 0, ""),
SyscallSucceeds());
ASSERT_THAT(umount2(dir1.path().c_str(), MNT_DETACH), SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
EXPECT_EQ(optionals[dir2.path()].size(), 1);
ASSERT_EQ(umount2(dir2.path().c_str(), MNT_DETACH), 0);
}
TEST(MountTest, UmountIgnoresPeersWithChildren) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount("", dir1.path().c_str(), kTmpfs, 0, ""), SyscallSucceeds());
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount(dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, 0),
SyscallSucceeds());
auto const child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
ASSERT_THAT(mount("", child_dir.path().c_str(), kTmpfs, 0, ""),
SyscallSucceeds());
auto const grandchild_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(child_dir.path()));
ASSERT_THAT(mount("", grandchild_dir.path().c_str(), kTmpfs, 0, ""),
SyscallSucceeds());
const std::string child_path1 =
JoinPath(dir1.path(), Basename(child_dir.path()));
const std::string child_path2 =
JoinPath(dir2.path(), Basename(child_dir.path()));
ASSERT_THAT(mount("", child_path2.c_str(), "", MS_PRIVATE, 0),
SyscallSucceeds());
const std::string grandchild_path2 =
JoinPath(child_path2, Basename(grandchild_dir.path()));
ASSERT_THAT(umount2(grandchild_path2.c_str(), MNT_DETACH), SyscallSucceeds());
// This umount event should not propagate to the peer at dir1 because its
// child mount still has its own child mount.
ASSERT_THAT(umount2(child_path2.c_str(), MNT_DETACH), SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
EXPECT_EQ(optionals[child_path2].size(), 0);
EXPECT_EQ(optionals[child_path1].size(), 1);
ASSERT_THAT(umount2(dir1.path().c_str(), MNT_DETACH), SyscallSucceeds());
ASSERT_THAT(umount2(dir2.path().c_str(), MNT_DETACH), SyscallSucceeds());
}
TEST(MountTest, BindSharedOnShared) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir3 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir4 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
// Dir 1 and 2 are part of peer group 'A', dir 3 and 4 are part of peer group
// 'B'.
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
auto const dir5 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const mnt3 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir3.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", dir3.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const mnt4 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir3.path().c_str(), dir4.path().c_str(), "", MS_BIND, "", MNT_DETACH));
const std::string dir5_path2 = JoinPath(dir2.path(), Basename(dir5.path()));
// Bind peer group 'A' to peer group 'B'.
auto const mnt5 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir4.path().c_str(), dir5.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
ASSERT_FALSE(optionals[dir3.path()].empty());
ASSERT_FALSE(optionals[dir4.path()].empty());
ASSERT_FALSE(optionals[dir5.path()].empty());
ASSERT_FALSE(optionals[dir5_path2].empty());
EXPECT_EQ(optionals[dir3.path()][0].shared, optionals[dir4.path()][0].shared);
EXPECT_EQ(optionals[dir4.path()][0].shared, optionals[dir5.path()][0].shared);
EXPECT_EQ(optionals[dir5.path()][0].shared, optionals[dir5_path2][0].shared);
EXPECT_NE(optionals[dir3.path()][0].shared, 0);
}
TEST(MountTest, BindSharedOnPrivate) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
auto const dir2 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const dir3 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dir4 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt3 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir3.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", dir3.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const mnt4 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir3.path().c_str(), dir4.path().c_str(), "", MS_BIND, "", MNT_DETACH));
// bind to private mount.
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir3.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
ASSERT_FALSE(optionals[dir3.path()].empty());
ASSERT_FALSE(optionals[dir4.path()].empty());
EXPECT_EQ(optionals[dir1.path()][0].shared, 0);
EXPECT_EQ(optionals[dir2.path()][0].shared, optionals[dir3.path()][0].shared);
EXPECT_EQ(optionals[dir3.path()][0].shared, optionals[dir4.path()][0].shared);
}
TEST(MountTest, BindPeerGroupsWithChildren) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir1.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir2.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", dir2.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
// dir3 and dir4 are child mounts of dir1.
auto const dir3 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const mnt3 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir3.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
auto const dir4 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const mnt4 = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir4.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
auto const mnt5 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
const std::string dir3_path2 = JoinPath(dir2.path(), Basename(dir3.path()));
const std::string dir4_path2 = JoinPath(dir2.path(), Basename(dir4.path()));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
ASSERT_FALSE(optionals[dir3.path()].empty());
EXPECT_NE(optionals[dir1.path()][0].shared, optionals[dir3.path()][0].shared);
EXPECT_NE(optionals[dir3.path()][0].shared, optionals[dir4.path()][0].shared);
EXPECT_NE(optionals[dir4.path()][0].shared, optionals[dir1.path()][0].shared);
EXPECT_EQ(optionals[dir3_path2].size(), 0);
EXPECT_EQ(optionals[dir4_path2].size(), 0);
}
TEST(MountTest, BindParentToChild) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir1.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir1.path()));
auto const mnt3 = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir1.path().c_str(), child_dir.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_FALSE(optionals[dir1.path()].empty());
ASSERT_FALSE(optionals[dir2.path()].empty());
ASSERT_FALSE(optionals[child_dir.path()].empty());
EXPECT_EQ(optionals[dir1.path()][0].shared, optionals[dir2.path()][0].shared);
EXPECT_EQ(optionals[dir2.path()][0].shared,
optionals[child_dir.path()][0].shared);
EXPECT_NE(optionals[dir1.path()][0].shared, 0);
}
TEST(MountTest, MountInfoHasRoot) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", parent.path(), kTmpfs, 0, "mode=0123", 0));
auto const child =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
auto const bind_mount = Mount(child.path(), child.path(), "", MS_BIND, "", 0);
std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
for (const auto& e : mounts) {
if (e.mount_point == child.path()) {
EXPECT_EQ(e.root, JoinPath("/", Basename(child.path())))
<< "Offending mount ID is: " << e.id;
}
if (e.mount_point == parent.path()) {
EXPECT_EQ(e.root, "/") << "Offending mount ID is: " << e.id;
}
}
}
TEST(MountTest, DeadMountsAreDecRefd) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
DisableSave ds;
std::string home = NewTempAbsPath();
ASSERT_NO_ERRNO(Mkdir(home));
ASSERT_THAT(chdir(home.c_str()), SyscallSucceeds());
constexpr char dirpath[] = "./file";
for (int i = 0; i < 10; ++i) {
const auto rest = [&] {
mkdir(dirpath, 0);
mount(dirpath, ".", 0, MS_BIND, 0);
rmdir(dirpath);
mkdir(dirpath, 0);
mount(dirpath, ".", 0, MS_BIND, 0);
};
EXPECT_THAT(InForkedProcess(rest), IsPosixErrorOkAndHolds(0));
}
}
TEST(MountTest, UmountSharedBind) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
std::string home = NewTempAbsPath();
ASSERT_NO_ERRNO(Mkdir(home));
ASSERT_THAT(chdir(home.c_str()), SyscallSucceeds());
constexpr char dirpath[] = "./file";
ASSERT_THAT(mkdir(dirpath, 0), SyscallSucceeds());
ASSERT_THAT(mount(dirpath, dirpath, 0, MS_BIND, 0), SyscallSucceeds());
ASSERT_THAT(mount(0, dirpath, 0, MS_SHARED, 0), SyscallSucceeds());
ASSERT_THAT(mount(dirpath, dirpath, 0, MS_BIND, 0), SyscallSucceeds());
ASSERT_THAT(mount(0, dirpath, 0, MS_SHARED, 0), SyscallSucceeds());
ASSERT_THAT(umount2(dirpath, MNT_DETACH), SyscallSucceeds());
ASSERT_THAT(umount2(dirpath, MNT_DETACH), SyscallSucceeds());
}
TEST(MountTest, MakeSlave) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir1.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SLAVE, 0), SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_NE(optionals[dir1.path()][0].shared, 0);
ASSERT_NE(optionals[dir2.path()][0].master, 0);
}
// Regression test: a bind mount that fails midway through attachment (e.g.
// because the mount namespace is at its mount limit) must not leave its
// half-constructed clone linked into the source's peer group. If it does, the
// dead clone can later be selected as a slave's master, silently breaking
// mount propagation to that slave.
TEST(MountTest, FailedBindDoesNotBreakPropagation) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
// Mount A: a shared tmpfs.
auto const dir_a = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt_a = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir_a.path(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", dir_a.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
// Create the future mountpoint inside A so that it exists in all of A's
// peers.
std::string const sub_a = JoinPath(dir_a.path(), "sub");
ASSERT_THAT(mkdir(sub_a.c_str(), 0755), SyscallSucceeds());
// Mount B: a bind of A, and its peer.
auto const dir_b = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt_b = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir_a.path(), dir_b.path(), "", MS_BIND, "", MNT_DETACH));
// The default mount limits (100k on Linux, 10k on gVisor) can make this test
// slow. Try and lower it if we're allowed to.
constexpr char kMountMax[] = "/proc/sys/fs/mount-max";
bool changed_mount_max = false;
int lower_mount_max = 100;
Cleanup restore_mount_max;
if (access(kMountMax, W_OK) == 0) {
std::string const old_max =
ASSERT_NO_ERRNO_AND_VALUE(GetContents(kMountMax));
ASSERT_NO_ERRNO(SetContents(kMountMax, absl::StrCat(lower_mount_max)));
changed_mount_max = true;
restore_mount_max = Cleanup([old_max, &kMountMax]() {
EXPECT_NO_ERRNO(SetContents(kMountMax, old_max));
});
}
// Fill the mount namespace up to its mount limit with private bind mounts,
// each on its own directory in the outer tmpfs. All of them are children of
// the outer mount, so detaching outer releases all of them with a single
// umount2() call.
auto const outer = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount("", outer.path().c_str(), kTmpfs, 0, 0), SyscallSucceeds());
auto outer_cleanup = Cleanup([&outer]() {
EXPECT_THAT(umount2(outer.path().c_str(), MNT_DETACH), SyscallSucceeds());
});
if (!changed_mount_max) {
// Repeatedly double the mounts in outer via recursive bind mounts of outer
// onto subdirectories within outer. Each successful step doubles the total
// number of mounts in outer.
std::vector<std::string> subdirs;
while (true) {
std::string const d = absl::StrCat(outer.path(), "/d", subdirs.size());
ASSERT_THAT(mkdir(d.c_str(), 0755), SyscallSucceeds());
if (mount(outer.path().c_str(), d.c_str(), nullptr, MS_BIND | MS_REC,
nullptr) != 0) {
break;
}
subdirs.push_back(d);
}
// Binary fill: try adding powers of 2 from largest to smallest to top off
// the namespace without exceeding the limit.
for (int i = static_cast<int>(subdirs.size()) - 1; i >= 0; i--) {
std::string const d = absl::StrCat(outer.path(), "/fill", i);
ASSERT_THAT(mkdir(d.c_str(), 0755), SyscallSucceeds());
mount(subdirs[i].c_str(), d.c_str(), nullptr, MS_BIND | MS_REC, nullptr);
}
}
bool full = false;
for (int i = 0; i < lower_mount_max; i++) {
std::string const d = absl::StrCat(outer.path(), "/single", i);
ASSERT_THAT(mkdir(d.c_str(), 0755), SyscallSucceeds());
if (mount(d.c_str(), d.c_str(), nullptr, MS_BIND, nullptr) != 0) {
const int err = errno;
ASSERT_EQ(err, ENOSPC) << strerror(err);
full = true;
break;
}
}
ASSERT_TRUE(full) << "couldn't fill up the mount namespace";
// Binding A while the namespace is at its mount limit must fail, and must
// not leave any trace of the aborted mount in A's peer group.
auto const dir_c = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount(dir_a.path().c_str(), dir_c.path().c_str(), nullptr,
MS_BIND, nullptr),
SyscallFailsWithErrno(ENOSPC));
// Release the mount budget again.
outer_cleanup.Release()();
// Make A a slave. Its new master must be B, its only remaining peer.
ASSERT_THAT(mount("", dir_a.path().c_str(), 0, MS_SLAVE, 0),
SyscallSucceeds());
// A mount under the shared peer B must propagate to the slave A.
std::string const sub_b = JoinPath(dir_b.path(), "sub");
ASSERT_THAT(mount("", sub_b.c_str(), kTmpfs, 0, 0), SyscallSucceeds());
auto sub_cleanup = Cleanup([&sub_b, &sub_a]() {
EXPECT_THAT(umount2(sub_b.c_str(), MNT_DETACH), SyscallSucceeds());
// The umount of sub_b may or may not have propagated to sub_a depending
// on whether the mount propagated there in the first place.
umount2(sub_a.c_str(), MNT_DETACH);
});
struct stat st_a, st_b;
ASSERT_THAT(stat(sub_b.c_str(), &st_b), SyscallSucceeds());
ASSERT_THAT(stat(sub_a.c_str(), &st_a), SyscallSucceeds());
EXPECT_EQ(st_a.st_dev, st_b.st_dev)
<< "mount under shared peer B did not propagate to slave A";
}
TEST(MountTest, MountMax) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
constexpr char kMountMax[] = "/proc/sys/fs/mount-max";
SKIP_IF(access(kMountMax, W_OK) != 0);
std::string const old_max = ASSERT_NO_ERRNO_AND_VALUE(GetContents(kMountMax));
auto const restore =
Cleanup([&]() { EXPECT_NO_ERRNO(SetContents(kMountMax, old_max)); });
// The limit must be at least 1 (Linux: proc_dointvec_minmax with
// extra1 == SYSCTL_ONE).
EXPECT_THAT(SetContents(kMountMax, "0"), PosixErrorIs(EINVAL));
// Lower the limit to the current number of mounts; any new mount must then
// fail with ENOSPC.
auto const mounts = ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountsEntries());
ASSERT_NO_ERRNO(SetContents(kMountMax, absl::StrCat(mounts.size())));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
EXPECT_THAT(mount("", dir.path().c_str(), kTmpfs, 0, 0),
SyscallFailsWithErrno(ENOSPC));
// Mounting works again once the limit is restored.
ASSERT_NO_ERRNO(SetContents(kMountMax, old_max));
auto const mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
}
TEST(MountTest, MakeSharedSlave) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir1.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SHARED, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_NE(optionals[dir1.path()][0].shared, 0);
ASSERT_NE(optionals[dir2.path()][0].shared, 0);
ASSERT_NE(optionals[dir2.path()][0].master, 0);
}
TEST(MountTest, PrivateMasterUnslaves) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const base = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const base_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", base.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", base.path().c_str(), "", MS_PRIVATE, 0),
SyscallSucceeds());
auto const dir1 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base.path()));
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir1.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base.path()));
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SHARED, 0),
SyscallSucceeds());
ASSERT_THAT(mount(0, dir1.path().c_str(), 0, MS_PRIVATE, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_EQ(optionals[dir1.path()][0].shared, 0);
ASSERT_EQ(optionals[dir2.path()][0].master, 0);
ASSERT_NE(optionals[dir2.path()][0].shared, 0);
}
TEST(MountTest, SlaveMaster) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt1 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir1.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dir1.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir1.path().c_str(), dir2.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_SHARED, 0),
SyscallSucceeds());
auto const dir3 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt3 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dir2.path().c_str(), dir3.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(0, dir3.path().c_str(), 0, MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount(0, dir2.path().c_str(), 0, MS_PRIVATE, 0),
SyscallSucceeds());
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_NE(optionals[dir1.path()][0].shared, 0);
ASSERT_EQ(optionals[dir2.path()][0].shared, 0);
ASSERT_EQ(optionals[dir2.path()][0].master, 0);
ASSERT_EQ(optionals[dir3.path()][0].master, optionals[dir1.path()][0].shared);
}
TEST(MountTest, BindSharedToSlave) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const src = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const src_mnt = ASSERT_NO_ERRNO_AND_VALUE(Mount(
src.path().c_str(), src.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", src.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dst_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dst_master.path().c_str(), dst_master.path().c_str(), "", MS_BIND,
"", MNT_DETACH));
ASSERT_THAT(mount("", dst_master.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dst = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dst_master.path().c_str(), dst.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
ASSERT_THAT(mount("", dst.path().c_str(), "", MS_SLAVE, 0),
SyscallSucceeds());
auto const dst_mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
src.path().c_str(), dst.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_EQ(optionals[src.path()][0].shared, optionals[dst.path()][1].shared);
ASSERT_EQ(optionals[dst.path()][0].master,
optionals[dst_master.path()][0].shared);
}
TEST(MountTest, BindSlaveToShared) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const src = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const src_mnt = ASSERT_NO_ERRNO_AND_VALUE(Mount(
src.path().c_str(), src.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", src.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const src_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const src_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(src.path().c_str(), src_master.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
ASSERT_THAT(mount("", src.path().c_str(), "", MS_SLAVE, 0),
SyscallSucceeds());
auto const dst = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_mnt = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dst.path().c_str(), dst.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dst.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dst_peer = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_peer_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dst.path().c_str(), dst_peer.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
auto const dst_mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
src.path().c_str(), dst.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_EQ(optionals[dst.path()][1].shared,
optionals[dst_peer.path()][1].shared);
ASSERT_EQ(optionals[dst.path()][1].master,
optionals[dst_peer.path()][1].master);
ASSERT_EQ(optionals[dst.path()][1].master,
optionals[src_master.path()][0].shared);
}
TEST(MountTest, BindSlaveToSlave) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const src = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const src_mnt = ASSERT_NO_ERRNO_AND_VALUE(Mount(
src.path().c_str(), src.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", src.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const src_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const src_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(src.path().c_str(), src_master.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
ASSERT_THAT(mount("", src.path().c_str(), "", MS_SLAVE, 0),
SyscallSucceeds());
auto const dst = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_mnt = ASSERT_NO_ERRNO_AND_VALUE(Mount(
dst.path().c_str(), dst.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", dst.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dst_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dst.path().c_str(), dst_master.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
ASSERT_THAT(mount("", dst.path().c_str(), "", MS_SLAVE, 0),
SyscallSucceeds());
auto const dst_mnt2 = ASSERT_NO_ERRNO_AND_VALUE(Mount(
src.path().c_str(), dst.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_EQ(optionals[dst.path()][1].master, optionals[src.path()][0].master);
}
// Test that mounting on a slave mount does not propagate to the master.
TEST(MountTest, SlavePropagationEvent) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dst_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dst_master.path().c_str(), dst_master.path().c_str(), "", MS_BIND,
"", MNT_DETACH));
ASSERT_THAT(mount("", dst_master.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
auto const dst = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const dst_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dst_master.path().c_str(), dst.path().c_str(), "", MS_BIND, "",
MNT_DETACH));
ASSERT_THAT(mount("", dst.path().c_str(), "", MS_SLAVE, 0),
SyscallSucceeds());
auto const child =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dst_master.path()));
const std::string master_child_path =
JoinPath(dst_master.path(), Basename(child.path()));
const std::string slave_child_path =
JoinPath(dst.path(), Basename(child.path()));
auto const slave_child_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", slave_child_path.c_str(), kTmpfs, 0, "", MNT_DETACH));
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
ASSERT_EQ(optionals[child.path()].size(), 0);
}
// We are building a propagation tree that looks like this:
/*
A <--> B <--> C <---> D
/|\ /| |\
/ F G J K H I
/
E<-->O
/|\
M L N
*/
// Propagating mount events across this tree should cover most propagation
// cases.
TEST(MountTest, LargeTreePropagationEvent) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
// 15 total mounts that should all get propagated to if we mount on A.
auto const a = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const b = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const c = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const d = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const e = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const f = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const g = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const h = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const i = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const j = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const k = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const l = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const m = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const n = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const o = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), a.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", a.path().c_str(), "", MS_SHARED, 0), SyscallSucceeds());
// Place E, F, and G in A's peer group, then make them slaves.
auto const e_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), e.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const f_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), f.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const g_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), g.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", e.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", f.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", g.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
// Add B to A's shared group.
auto const b_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), b.path().c_str(), "", MS_BIND, "", MNT_DETACH));
// Add C to A's shared group and place J and K in C's peer group, then make
// them slaves.
auto const c_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), c.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const j_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(c.path().c_str(), j.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const k_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(c.path().c_str(), k.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", j.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", k.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
// Add D to A's shared group and place H and I in Ds peer group, then make
// them slaves.
auto const d_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path().c_str(), d.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const h_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(d.path().c_str(), h.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const i_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(d.path().c_str(), i.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", h.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", i.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
// Make E shared and create a group with O.
ASSERT_THAT(mount("", e.path().c_str(), "", MS_SHARED, 0), SyscallSucceeds());
auto const o_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(e.path().c_str(), o.path().c_str(), "", MS_BIND, "", MNT_DETACH));
// Add M, L and N to K's shared group and make them slaves of O.
auto const m_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(o.path().c_str(), m.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const l_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(o.path().c_str(), l.path().c_str(), "", MS_BIND, "", MNT_DETACH));
auto const n_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(o.path().c_str(), n.path().c_str(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", m.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", l.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", n.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
ASSERT_THAT(mount("", a.path().c_str(), kTmpfs, 0, ""), SyscallSucceeds());
std::vector<ProcMountInfoEntry> mounts_after_mount =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
ASSERT_EQ(mounts_after_mount.size(), mounts.size() + 15);
auto optionals = ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
// A, B, C, and D are all mounted over and in a peer group.
ASSERT_NE(optionals[a.path()][1].shared, 0);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[b.path()][1].shared);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[c.path()][1].shared);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[d.path()][1].shared);
// E, F, G, H, I, J, K are all mounted over and slave to A's peer group.
ASSERT_EQ(optionals[a.path()][1].shared, optionals[e.path()][1].master);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[f.path()][1].master);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[g.path()][1].master);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[h.path()][1].master);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[i.path()][1].master);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[j.path()][1].master);
ASSERT_EQ(optionals[a.path()][1].shared, optionals[k.path()][1].master);
// E and O are all mounted over and in a peer group.
ASSERT_EQ(optionals[e.path()][1].shared, optionals[o.path()][1].shared);
// L, M, and N are all mounted over and slaves to E's peer group.
ASSERT_EQ(optionals[e.path()][1].shared, optionals[l.path()][1].master);
ASSERT_EQ(optionals[e.path()][1].shared, optionals[m.path()][1].master);
ASSERT_EQ(optionals[e.path()][1].shared, optionals[n.path()][1].master);
ASSERT_THAT(umount2(a.path().c_str(), MNT_DETACH), SyscallSucceeds());
std::vector<ProcMountInfoEntry> mounts_after_umount =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
ASSERT_EQ(mounts_after_umount.size(), mounts.size());
}
TEST(MountTest, MaxMountsWithSlave) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const parent_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", parent.path(), kTmpfs, 0, "mode=0123", MNT_DETACH));
auto const a =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
auto const b =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
auto const c =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", a.path(), kTmpfs, 0, "mode=0123", MNT_DETACH));
ASSERT_THAT(mount("", a.path().c_str(), "", MS_SHARED, 0), SyscallSucceeds());
auto const b_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), b.path(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", b.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
ASSERT_THAT(mount("", b.path().c_str(), "", MS_SHARED, 0), SyscallSucceeds());
auto const c_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(b.path(), c.path(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", c.path().c_str(), "", MS_SLAVE, 0), SyscallSucceeds());
auto const d = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
auto const e = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
int mount_max = 10000;
bool mount_max_exists =
ASSERT_NO_ERRNO_AND_VALUE(Exists("/proc/sys/fs/mount-max"));
if (mount_max_exists) {
std::string mount_max_string;
ASSERT_NO_ERRNO(GetContents("/proc/sys/fs/mount-max", &mount_max_string));
ASSERT_TRUE(absl::SimpleAtoi(mount_max_string, &mount_max));
}
// Each bind mount doubles the number of mounts in the propagation tree
// starting with 3. The number of binds we can do before failing is
// log2((max_mounts-num_current_mounts)/3).
std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
int num_binds = static_cast<int>(std::log2((mount_max - mounts.size()) / 3));
for (int i = 0; i < num_binds; i++) {
ASSERT_THAT(
mount(d.path().c_str(), d.path().c_str(), nullptr, MS_BIND, nullptr),
SyscallSucceeds());
ASSERT_THAT(mount("", d.path().c_str(), "", MS_SHARED, 0),
SyscallSucceeds());
}
for (int i = 0; i < 2; i++) {
EXPECT_THAT(
mount(d.path().c_str(), d.path().c_str(), nullptr, MS_BIND, nullptr),
SyscallFailsWithErrno(ENOSPC));
}
}
TEST(MountTest, SetPropagationRecursive) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath a = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", a.path(), kTmpfs, 0, "mode=0123", MNT_DETACH));
const auto b = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
auto const b_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", b.path(), kTmpfs, 0, "mode=0123", MNT_DETACH));
const auto c = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(b.path()));
auto const c_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", c.path(), kTmpfs, 0, "mode=0123", MNT_DETACH));
const auto d = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(c.path()));
auto const d_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", d.path(), kTmpfs, 0, "mode=0123", MNT_DETACH));
ASSERT_THAT(mount("", a.path().c_str(), "", MS_SHARED | MS_REC, 0),
SyscallSucceeds());
absl::flat_hash_map<std::string, std::vector<MountOptional>> optionals =
ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
EXPECT_NE(optionals[a.path()][0].shared, 0);
EXPECT_NE(optionals[b.path()][0].shared, 0);
EXPECT_NE(optionals[c.path()][0].shared, 0);
EXPECT_NE(optionals[d.path()][0].shared, 0);
}
TEST(MountTest, SetSlaveRecursive) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const auto a = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), a.path(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", a.path().c_str(), "", MS_SHARED, 0), SyscallSucceeds());
const auto a_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const a_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), a_master.path(), "", MS_BIND, "", MNT_DETACH));
const auto b = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
auto const b_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), b.path(), "", MS_BIND, "", MNT_DETACH));
const auto b_master = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const b_master_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(b.path(), b_master.path(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount("", a.path().c_str(), "", MS_SLAVE | MS_REC, 0),
SyscallSucceeds());
absl::flat_hash_map<std::string, std::vector<MountOptional>> optionals =
ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
EXPECT_EQ(optionals[a.path()][0].master,
optionals[a_master.path()][0].shared);
EXPECT_EQ(optionals[b.path()][0].master,
optionals[b_master.path()][0].shared);
}
TEST(MountTest, RecursiveBind) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const auto a = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), a.path(), "", MS_BIND, "", MNT_DETACH));
const auto b = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
auto const b_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(b.path(), b.path(), "", MS_BIND, "", MNT_DETACH));
const auto c = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(b.path()));
const auto d = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const d_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), d.path(), "", MS_BIND | MS_REC, "", MNT_DETACH));
// Write to child1 in dir1.
const std::string filename = "foo.txt";
const std::string contents = "barbaz";
ASSERT_NO_ERRNO(
CreateWithContents(JoinPath(c.path(), filename), contents, 0666));
// Verify both directories have the same nodes.
const std::string path =
JoinPath(d.path(), Basename(b.path()), Basename(c.path()), filename);
std::string output;
ASSERT_NO_ERRNO(GetContents(path, &output));
EXPECT_EQ(output, contents);
}
TEST(MountTest, MaxRecursiveBind) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const auto a = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), a.path(), "", MS_BIND, "", MNT_DETACH));
const auto b = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
int mount_max = 10000;
bool mount_max_exists =
ASSERT_NO_ERRNO_AND_VALUE(Exists("/proc/sys/fs/mount-max"));
if (mount_max_exists) {
std::string mount_max_string;
ASSERT_NO_ERRNO(GetContents("/proc/sys/fs/mount-max", &mount_max_string));
ASSERT_TRUE(absl::SimpleAtoi(mount_max_string, &mount_max));
}
const std::vector<ProcMountInfoEntry> mounts =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
int num_binds = static_cast<int>(std::log2(mount_max - mounts.size()));
for (int i = 0; i < num_binds; i++) {
ASSERT_THAT(mount(a.path().c_str(), b.path().c_str(), nullptr,
MS_BIND | MS_REC, nullptr),
SyscallSucceeds());
}
ASSERT_THAT(mount(a.path().c_str(), b.path().c_str(), nullptr,
MS_BIND | MS_REC, nullptr),
SyscallFailsWithErrno(ENOSPC));
}
TEST(MountTest, RecursiveBindPropagation) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const auto parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const parent_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(parent.path(), parent.path(), "", MS_BIND, "", MNT_DETACH));
const auto a =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
const auto b =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
const auto c =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
auto const a_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("test", a.path(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount("", a.path().c_str(), "", MS_SHARED, 0), SyscallSucceeds());
auto const b_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), b.path(), "", MS_BIND, "", MNT_DETACH));
auto const c_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(a.path(), c.path(), "", MS_BIND, "", MNT_DETACH));
const auto d =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path()));
const auto f = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(a.path()));
auto const d_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(d.path(), d.path(), "", MS_BIND, "", MNT_DETACH));
const auto e = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(d.path()));
auto const e_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(e.path(), e.path(), "", MS_BIND, "", MNT_DETACH));
auto const f_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(d.path(), f.path(), "", MS_BIND | MS_REC, "", MNT_DETACH));
absl::flat_hash_map<std::string, std::vector<MountOptional>> optionals =
ASSERT_NO_ERRNO_AND_VALUE(MountOptionals());
auto b_e_path = JoinPath(b.path(), Basename(f.path()), Basename(e.path()));
ASSERT_FALSE(optionals[b_e_path].empty());
auto c_e_path = JoinPath(c.path(), Basename(f.path()), Basename(e.path()));
ASSERT_FALSE(optionals[c_e_path].empty());
}
TEST(MountTest, MountNamespace) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "mode=0700", 0));
auto const file_path = JoinPath(dir.path(), "foo");
EXPECT_NO_ERRNO(Open(file_path, O_CREAT | O_RDWR, 0777));
pid_t child = fork();
if (child == 0) {
// Create a new mount namespace and umount the test mount from it.
TEST_PCHECK(unshare(CLONE_NEWNS) == 0);
TEST_PCHECK(access(file_path.c_str(), F_OK) == 0);
TEST_PCHECK(umount2(dir.path().c_str(), MNT_DETACH) == 0);
_exit(0);
}
ASSERT_THAT(child, SyscallSucceeds());
int status;
ASSERT_THAT(waitpid(child, &status, 0), SyscallSucceedsWithValue(child));
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
// Check that the test mount is still here.
EXPECT_NO_ERRNO(Open(file_path, O_RDWR));
}
TEST(MountTest, MountNamespaceSetns) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "mode=0700", MNT_DETACH));
auto const file_path = JoinPath(dir.path(), "foo");
EXPECT_NO_ERRNO(Open(file_path, O_CREAT | O_RDWR, 0777));
const FileDescriptor nsfd =
ASSERT_NO_ERRNO_AND_VALUE(Open("/proc/thread-self/ns/mnt", O_RDONLY));
pid_t child = fork();
if (child == 0) {
TEST_PCHECK(unshare(CLONE_NEWNS) == 0);
TEST_PCHECK(umount2(dir.path().c_str(), MNT_DETACH) == 0);
TEST_PCHECK(setns(nsfd.get(), CLONE_NEWNS) == 0);
TEST_PCHECK(access(file_path.c_str(), F_OK) == 0);
_exit(0);
}
ASSERT_THAT(child, SyscallSucceeds());
int status;
ASSERT_THAT(waitpid(child, &status, 0), SyscallSucceedsWithValue(child));
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
}
TEST(MountTest, MountNamespacePropagation) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto const mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "mode=0700", MNT_DETACH));
auto child_dir = JoinPath(dir.path(), "test");
auto const file_path = JoinPath(child_dir, "foo");
auto const file2_path = JoinPath(child_dir, "boo");
ASSERT_THAT(mount(NULL, dir.path().c_str(), NULL, MS_SHARED, NULL),
SyscallSucceeds());
ASSERT_THAT(mkdir(child_dir.c_str(), 0700), SyscallSucceeds());
ASSERT_THAT(mount("child", child_dir.c_str(), kTmpfs, 0, NULL),
SyscallSucceeds());
EXPECT_NO_ERRNO(Open(file_path, O_CREAT | O_RDWR, 0777));
pid_t child = fork();
if (child == 0) {
TEST_PCHECK(unshare(CLONE_NEWNS) == 0);
TEST_PCHECK(access(file_path.c_str(), F_OK) == 0);
// The test mount has to be umounted from the second mount namespace too.
TEST_PCHECK(umount2(child_dir.c_str(), MNT_DETACH) == 0);
// The new mount has to be propagated to the second mount namespace.
TEST_PCHECK(mount("test2", child_dir.c_str(), kTmpfs, 0, NULL) == 0);
TEST_PCHECK(mknod(file2_path.c_str(), 0777 | S_IFREG, 0) == 0);
_exit(0);
}
ASSERT_THAT(child, SyscallSucceeds());
int status;
ASSERT_THAT(waitpid(child, &status, 0), SyscallSucceedsWithValue(child));
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
// Check that the test mount is still here.
EXPECT_NO_ERRNO(Open(file2_path, O_RDWR));
EXPECT_THAT(umount2(child_dir.c_str(), MNT_DETACH), SyscallSucceeds());
}
TEST(MountTest, MountNamespaceSlavesNewUserNamespace) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const Cleanup dir_mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount(NULL, dir.path().c_str(), NULL, MS_SHARED, NULL),
SyscallSucceeds());
const TempPath child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
const std::string file_path = JoinPath(child_dir.path(), "foo");
const std::string file2_path = JoinPath(child_dir.path(), "boo");
const std::function<void()> parent = [&] {
TEST_CHECK_SUCCESS(
mount("child", child_dir.path().c_str(), kTmpfs, 0, NULL));
TEST_CHECK_SUCCESS(open(file_path.c_str(), O_CREAT | O_RDWR, 0777));
};
const std::function<void()> child = [&] {
TEST_CHECK_SUCCESS(access(JoinPath(child_dir.path(), "foo").c_str(), F_OK));
// These mount operations will not propagate to the other namespace
// because it is a slave mount.
TEST_CHECK_SUCCESS(umount2(child_dir.path().c_str(), MNT_DETACH));
TEST_CHECK_SUCCESS(
mount("test2", child_dir.path().c_str(), kTmpfs, 0, NULL));
TEST_CHECK_SUCCESS(mknod(file2_path.c_str(), 0777 | S_IFREG, 0));
TEST_CHECK_SUCCESS(umount2(child_dir.path().c_str(), MNT_DETACH));
// This should fail because the mount is locked.
TEST_CHECK_ERRNO(umount2(child_dir.path().c_str(), MNT_DETACH), EINVAL);
// Check that there is a master entry in mountinfo.
int fd = open("/proc/self/mountinfo", O_RDONLY);
TEST_CHECK(fd >= 0);
char child_mountinfo[0x8000];
int size = 0;
while (true) {
int ret =
read(fd, child_mountinfo + size, sizeof(child_mountinfo) - size);
TEST_CHECK(ret != -1);
size += ret;
if (ret == 0) {
break;
}
}
TEST_CHECK(absl::StrContains(child_mountinfo, "master:"));
};
EXPECT_THAT(InForkedUserMountNamespace(parent, child),
IsPosixErrorOkAndHolds(0));
// Check that the test mount is still here.
EXPECT_EQ(Open(file2_path, O_RDWR).error().errno_value(), ENOENT);
EXPECT_THAT(umount2(child_dir.path().c_str(), MNT_DETACH), SyscallSucceeds());
}
TEST(MountTest, LockedMountStopsNonRecBind) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const Cleanup dir_mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", dir.path(), kTmpfs, 0, "", MNT_DETACH));
const TempPath child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
const Cleanup child_mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", child_dir.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
const std::string foo_dir = JoinPath(dir.path(), "foo");
const std::function<void()> child_fn = [&] {
TEST_CHECK_SUCCESS(mkdir(foo_dir.c_str(), 0700));
TEST_CHECK_ERRNO(
mount(dir.path().c_str(), foo_dir.c_str(), "", MS_BIND, ""), EINVAL);
TEST_CHECK_SUCCESS(
mount(dir.path().c_str(), foo_dir.c_str(), "", MS_BIND | MS_REC, ""));
};
EXPECT_THAT(InForkedUserMountNamespace([] {}, child_fn),
IsPosixErrorOkAndHolds(0));
}
// This test checks that a mount tree that propagates from a more privileged
// mount namespace cannot be partially unmounted. It must be unmounted as a
// single unit as described in point 4 of the notes in
// https://man7.org/linux/man-pages/man7/mount_namespaces.7.html. This test
// also checks that unmounting a propagated mount tree does not reveal the
// contents of overmounted filesystems from the more privileged mount namespace.
TEST(MountTest, UmountPropagatedSubtreeFromPrivilegedNS) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const Cleanup dir_mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir.path(), dir.path(), "", MS_BIND, "", MNT_DETACH));
ASSERT_THAT(mount(NULL, dir.path().c_str(), NULL, MS_SHARED, NULL),
SyscallSucceeds());
const TempPath child_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
const TempPath sibling_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
const Cleanup child_mount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", child_dir.path(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(mount(NULL, child_dir.path().c_str(), NULL, MS_PRIVATE, NULL),
SyscallSucceeds());
const TempPath grandchild_dir =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(child_dir.path()));
ASSERT_THAT(open(JoinPath(grandchild_dir.path(), "foo").c_str(),
O_CREAT | O_RDWR, 0777),
SyscallSucceeds());
const Cleanup grandchild_mnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", grandchild_dir.path(), kTmpfs, 0, "", MNT_DETACH));
ASSERT_THAT(
mount(NULL, grandchild_dir.path().c_str(), NULL, MS_PRIVATE, NULL),
SyscallSucceeds());
const std::string grandsibling_dir =
JoinPath(sibling_dir.path(), Basename(grandchild_dir.path()));
const std::function<void()> parent = [&] {
TEST_CHECK_SUCCESS(mount(child_dir.path().c_str(),
sibling_dir.path().c_str(), "", MS_BIND | MS_REC,
""));
TEST_CHECK_SUCCESS(
mount("", sibling_dir.path().c_str(), "", MS_PRIVATE | MS_REC, ""));
};
// You can umount an entire subtree that propagated from a more privileged
// mount namespace, but can't umount only part of the subtree.
const std::string file_path =
JoinPath(Basename(grandchild_dir.path()), "foo");
const std::function<void()> child = [&] {
TEST_CHECK_ERRNO(umount2(grandsibling_dir.c_str(), MNT_DETACH), EINVAL);
int dirfd = open(sibling_dir.path().c_str(), O_RDONLY | O_DIRECTORY);
TEST_PCHECK(dirfd >= 0);
TEST_CHECK_SUCCESS(umount2(sibling_dir.path().c_str(), MNT_DETACH));
// Check to ensure you cannot access an overmounted file with openat after
// the mount unit has been destroyed.
TEST_CHECK_ERRNO(openat(dirfd, file_path.c_str(), O_RDONLY), ENOENT);
};
EXPECT_THAT(InForkedUserMountNamespace(parent, child),
IsPosixErrorOkAndHolds(0));
}
TEST(MountTest, MountFailsOnPseudoFilesystemMountpoint) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const fd = ASSERT_NO_ERRNO_AND_VALUE(NewEventFD(0, 0));
std::string path = absl::StrCat("/proc/self/fd/", fd.get());
// After 0d039eac6e595 ("fix a couple of races in MNT_TREE_BENEATH handling
// by do_move_mount()"), this hits fs/namespace.c:do_lock_mount() =>
// !is_mounted() (eventfds use fs/anon_inodes.c:anon_inode_mnt, which has
// real_mount(mnt)->mnt_ns == fs/mount.h:MNT_NS_INTERNAL == ERR_PTR(-EINVAL)
// from kern_mount()) and returns ENOENT.
EXPECT_THAT(
mount("test", path.c_str(), kTmpfs, 0, 0),
AnyOf(SyscallFailsWithErrno(EINVAL), SyscallFailsWithErrno(ENOENT)));
}
TEST(MountTest, ChangeMountFlags) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const auto flag = MS_NODEV;
const auto dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const auto dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const auto mount_cleanup = ASSERT_NO_ERRNO_AND_VALUE(
Mount(dir1.path(), dir2.path(), kTmpfs, MS_BIND, "", 0));
struct statfs st;
EXPECT_THAT(mount(dir1.path().c_str(), dir2.path().c_str(), kTmpfs,
MS_REMOUNT | MS_BIND | flag, ""),
SyscallSucceeds());
EXPECT_THAT(statfs(dir2.path().c_str(), &st), SyscallSucceeds());
EXPECT_EQ(st.f_flags & flag, flag);
// Resets mount flags.
EXPECT_THAT(mount(dir1.path().c_str(), dir2.path().c_str(), kTmpfs,
MS_REMOUNT | MS_BIND, ""),
SyscallSucceeds());
ASSERT_THAT(statfs(dir2.path().c_str(), &st), SyscallSucceeds());
ASSERT_EQ(st.f_flags & flag, 0);
}
constexpr int kLockableFlags = MS_RDONLY | MS_NOEXEC | MS_NODEV | MS_NOSUID;
// Sets kLockableFlags on the mount at `path`.
void SetLockableFlags(const std::string& path) {
ASSERT_THAT(mount("", path.c_str(), nullptr,
MS_REMOUNT | MS_BIND | kLockableFlags, ""),
SyscallSucceeds());
}
TEST(MountTest, ChangeMountFlagsOfLockedMount) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const Cleanup mount_cleanup =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
ASSERT_NO_FATAL_FAILURE(SetLockableFlags(dir.path()));
const std::string path = dir.path();
const std::string file_path = JoinPath(path, "foo");
const std::function<void()> child = [&] {
// The mount was copied into a new user namespace, so none of its flags may
// be cleared.
for (const int flag : {MS_RDONLY, MS_NOEXEC, MS_NODEV, MS_NOSUID}) {
TEST_CHECK_ERRNO(
mount("", path.c_str(), nullptr,
MS_REMOUNT | MS_BIND | (kLockableFlags & ~flag), ""),
EPERM);
}
TEST_CHECK_ERRNO(mount("", path.c_str(), nullptr, MS_REMOUNT | MS_BIND, ""),
EPERM);
// The mount is still read-only.
TEST_CHECK_ERRNO(open(file_path.c_str(), O_CREAT | O_RDWR, 0666), EROFS);
// A remount that keeps all of the locked flags set is allowed.
TEST_CHECK_SUCCESS(mount("", path.c_str(), nullptr,
MS_REMOUNT | MS_BIND | kLockableFlags, ""));
};
EXPECT_THAT(InForkedUserMountNamespace([] {}, child),
IsPosixErrorOkAndHolds(0));
// The flags are not locked in the namespace that owns the mount.
EXPECT_THAT(mount("", path.c_str(), nullptr, MS_REMOUNT | MS_BIND, ""),
SyscallSucceeds());
struct statfs st;
ASSERT_THAT(statfs(path.c_str(), &st), SyscallSucceeds());
EXPECT_EQ(st.f_flags & kLockableFlags, 0);
}
TEST(MountTest, LockedMountFlagsAreInheritedByBind) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const Cleanup mount_cleanup =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
ASSERT_NO_FATAL_FAILURE(SetLockableFlags(dir.path()));
const TempPath target = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
const std::string path = dir.path();
const std::string target_path = target.path();
const std::function<void()> child = [&] {
// Binding the locked mount elsewhere must not result in a mount for which
// flags can be cleared.
TEST_CHECK_SUCCESS(
mount(path.c_str(), target_path.c_str(), "", MS_BIND, ""));
for (const int flag : {MS_RDONLY, MS_NOEXEC, MS_NODEV, MS_NOSUID}) {
TEST_CHECK_ERRNO(
mount("", target_path.c_str(), nullptr,
MS_REMOUNT | MS_BIND | (kLockableFlags & ~flag), ""),
EPERM);
}
TEST_CHECK_SUCCESS(mount("", target_path.c_str(), nullptr,
MS_REMOUNT | MS_BIND | kLockableFlags, ""));
// The bind mount itself was created in this namespace, so unlike the mount
// it was cloned from, it can be unmounted.
TEST_CHECK_SUCCESS(umount2(target_path.c_str(), MNT_DETACH));
};
EXPECT_THAT(InForkedUserMountNamespace([] {}, child),
IsPosixErrorOkAndHolds(0));
}
TEST(MountTest, RemountUnmounted) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
EXPECT_THAT(mount("", dir.path().c_str(), kTmpfs, MS_REMOUNT, ""),
SyscallFailsWithErrno(EINVAL));
}
TEST(MountTest, DetachedMountBindFails) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
const TempPath path1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
Cleanup mount_cleanup = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", path1.path().c_str(), kTmpfs, 0, "", MNT_DETACH));
mount_cleanup.Release();
const FileDescriptor fd =
ASSERT_NO_ERRNO_AND_VALUE(Open(path1.path().c_str(), O_RDONLY));
std::string fd_path = absl::Substitute("/proc/self/fd/$0", fd.get());
ASSERT_THAT(umount2(path1.path().c_str(), MNT_DETACH), SyscallSucceeds());
const TempPath path2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
EXPECT_THAT(mount(fd_path.c_str(), path2.path().c_str(), "", MS_BIND, 0),
SyscallFailsWithErrno(EINVAL));
}
TEST(MountTest, MountProc) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
// Mount procfs with a NULL source to a temporary directory.
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
ASSERT_THAT(mount(NULL, dir.path().c_str(), "proc", 0, NULL),
SyscallSucceeds());
auto cleanup = Cleanup([&dir] {
EXPECT_THAT(umount2(dir.path().c_str(), 0), SyscallSucceeds());
});
// Verify that /proc/self/mountinfo describes the device as "none".
const std::vector<ProcMountInfoEntry> mountinfo =
ASSERT_NO_ERRNO_AND_VALUE(ProcSelfMountInfoEntries());
for (auto const& e : mountinfo) {
if (e.mount_point == dir.path()) {
EXPECT_EQ(e.fstype, "proc");
EXPECT_EQ(e.mount_source, "none");
}
}
}
TEST(MountTest, OverlayfsSgidBitIsCopiedUp) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto base_dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
// Overlayfs can not be used as upper layer for another overlayfs mount. If
// running in overlayfs, create a tmpfs mount to use as the upper layer.
bool in_overlayfs = ASSERT_NO_ERRNO_AND_VALUE(IsOverlayfs(base_dir.path()));
if (in_overlayfs) {
ASSERT_THAT(
mount("tmpfs", base_dir.path().c_str(), "tmpfs", 0, "mode=1777"),
SyscallSucceeds());
}
auto tmpfs_cleanup = Cleanup([&base_dir, &in_overlayfs] {
if (in_overlayfs) {
ASSERT_THAT(umount2(base_dir.path().c_str(), MNT_DETACH),
SyscallSucceeds());
}
});
// Create the files under test in `lower` and set the S_ISGID bit on them.
auto lower =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
struct FileUT {
absl::string_view name;
void (*create)(const std::string& path);
};
static constexpr std::array kFilesUnderTest = {
FileUT{"setgid_dir",
[](const std::string& path) {
ASSERT_THAT(mkdir(path.c_str(), 0755), SyscallSucceeds());
}},
FileUT{"setgid_empty_file",
[](const std::string& path) {
ASSERT_NO_ERRNO_AND_VALUE(Open(path, O_CREAT | O_RDWR, 0755));
}},
FileUT{"setgid_nonempty_file",
[](const std::string& path) {
ASSERT_NO_ERRNO(CreateWithContents(path, "junk", 0755));
}},
};
for (const auto& file_ut : kFilesUnderTest) {
std::string lower_target = lower.path() + "/" + std::string(file_ut.name);
file_ut.create(lower_target);
struct stat st_lower;
ASSERT_THAT(stat(lower_target.c_str(), &st_lower), SyscallSucceeds());
ASSERT_THAT(chmod(lower_target.c_str(), st_lower.st_mode | S_ISGID),
SyscallSucceeds());
ASSERT_THAT(stat(lower_target.c_str(), &st_lower), SyscallSucceeds());
ASSERT_TRUE(st_lower.st_mode & S_ISGID);
}
// Mount the overlayfs.
auto upper =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
auto work = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
auto merged =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
std::string opts = "lowerdir=" + lower.path() + ",upperdir=" + upper.path() +
",workdir=" + work.path();
ASSERT_THAT(
mount("overlay", merged.path().c_str(), "overlay", 0, opts.c_str()),
SyscallSucceeds());
auto overlayfs_cleanup =
Cleanup([&merged] { umount2(merged.path().c_str(), MNT_DETACH); });
for (const auto& file_ut : kFilesUnderTest) {
SCOPED_TRACE(file_ut.name);
// The S_ISGID bit is visible before any copy-up took place.
std::string merged_target = merged.path() + "/" + std::string(file_ut.name);
struct stat st_merged;
ASSERT_THAT(stat(merged_target.c_str(), &st_merged), SyscallSucceeds());
ASSERT_TRUE(st_merged.st_mode & S_ISGID);
// Touch the target to force a copy-up to `upper`.
ASSERT_THAT(utimensat(AT_FDCWD, merged_target.c_str(), nullptr, 0),
SyscallSucceeds());
// The S_ISGID bit must also be copied up.
std::string upper_target = upper.path() + "/" + std::string(file_ut.name);
struct stat upper_st_after_touch;
ASSERT_THAT(stat(upper_target.c_str(), &upper_st_after_touch),
SyscallSucceeds());
EXPECT_TRUE(upper_st_after_touch.st_mode & S_ISGID);
struct stat merged_st_after_touch;
ASSERT_THAT(stat(merged_target.c_str(), &merged_st_after_touch),
SyscallSucceeds());
EXPECT_TRUE(merged_st_after_touch.st_mode & S_ISGID);
}
}
// Renaming a directory on an overlay inside a user namespace requires
// user.overlay.* xattrs to mark the directory opaque.
TEST(MountTest, OverlayfsDirectoryRenameInUserNamespace) {
// Test fails in gVisor running on <6.0 due to fsgofer getting permission
// errors on `mknod`.
SKIP_IF(ASSERT_NO_ERRNO_AND_VALUE(GetHostKernelVersion()).major < 6);
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(CanCreateUserNamespace()));
auto base_dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
bool in_overlayfs = ASSERT_NO_ERRNO_AND_VALUE(IsOverlayfs(base_dir.path()));
const std::function<void()> parent = [] {};
const std::function<void()> child = [&base_dir, &in_overlayfs] {
// Overlayfs can not be used as upper layer for another overlayfs mount. If
// running in overlayfs, create a tmpfs mount to use as the upper layer.
if (in_overlayfs) {
TEST_CHECK_SUCCESS(mount("tmpfs", base_dir.path().c_str(), "tmpfs", 0,
"mode=1777,size=10m"));
}
auto tmpfs_cleanup = Cleanup([&base_dir, &in_overlayfs] {
if (in_overlayfs) {
TEST_CHECK_SUCCESS(umount2(base_dir.path().c_str(), 0));
}
});
auto lower = JoinPath(base_dir.path(), "lower");
auto upper = JoinPath(base_dir.path(), "upper");
auto work = JoinPath(base_dir.path(), "work");
auto merged = JoinPath(base_dir.path(), "merged");
TEST_CHECK_SUCCESS(mkdir(lower.c_str(), 0755));
TEST_CHECK_SUCCESS(mkdir(upper.c_str(), 0755));
TEST_CHECK_SUCCESS(mkdir(work.c_str(), 0755));
TEST_CHECK_SUCCESS(mkdir(merged.c_str(), 0755));
// 1. Create the DESTINATION directory in lower.
// (It must be empty so standard POSIX rename allows overwriting it).
{
auto lower_renamed = JoinPath(lower, "renamed");
TEST_CHECK_SUCCESS(mkdir(lower_renamed.c_str(), 0755));
}
std::string opts = "lowerdir=" + lower + ",upperdir=" + upper +
",workdir=" + work + ",userxattr";
TEST_CHECK_SUCCESS(
mount("overlay", merged.c_str(), "overlay", 0, opts.c_str()));
auto overlayfs_cleanup =
Cleanup([&merged] { TEST_CHECK_SUCCESS(umount2(merged.c_str(), 0)); });
// 2. Create the SOURCE directory directly in merged.
// Because it doesn't exist in lower, it is a "pure upper" directory.
auto mydir = JoinPath(merged, "mydir");
TEST_CHECK_SUCCESS(mkdir(mydir.c_str(), 0755));
int fd =
open(JoinPath(mydir, "file.txt").c_str(), O_WRONLY | O_CREAT, 0644);
TEST_CHECK(fd >= 0);
TEST_CHECK_SUCCESS(close(fd));
// 3. Rename the pure upper directory over the existing lower directory.
// - This avoids EXDEV on Linux because 'mydir' is pure upper.
// - This forces the kernel to apply user.overlay.opaque="y" to 'renamed'
// so that 'lower/renamed' is hidden.
auto renamed = JoinPath(merged, "renamed");
TEST_CHECK_SUCCESS(rename(mydir.c_str(), renamed.c_str()));
// 4. Verify the rename succeeded and contents are correct
struct stat st;
TEST_CHECK_SUCCESS(stat(renamed.c_str(), &st));
TEST_CHECK(S_ISDIR(st.st_mode));
// Original directory should be gone
TEST_CHECK(stat(mydir.c_str(), &st) == -1 && errno == ENOENT);
// File inside should have moved with the directory
TEST_CHECK_SUCCESS(stat(JoinPath(renamed, "file.txt").c_str(), &st));
TEST_CHECK(S_ISREG(st.st_mode));
};
EXPECT_THAT(InForkedUserMountNamespace(parent, child),
IsPosixErrorOkAndHolds(0));
}
// Test that overlay can be mounted with a gofer upper layer. Runs some basic
// overlayfs tests to confirm basic functionality.
TEST(MountTest, OverlayfsOnGoferBehavior) {
// Test fails in gVisor running on <6.0 due to fsgofer getting permission
// errors on `mknod`.
SKIP_IF(ASSERT_NO_ERRNO_AND_VALUE(GetHostKernelVersion()).major < 6);
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto base_dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
// We only want to test overlayfs on gofer.
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(IsGoferfs(base_dir.path())));
// Create directories for overlayfs mount.
auto lower =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
auto upper =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
auto work = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
auto merged =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(base_dir.path()));
// Set up lower layer with some content.
const std::string kTestFile = "testfile";
const std::string kTestFileContent = "lower_content";
std::string lower_file = JoinPath(lower.path(), kTestFile);
ASSERT_NO_ERRNO(CreateWithContents(lower_file, kTestFileContent, 0644));
const std::string kTestDirName = "testdir";
std::string lower_dir = JoinPath(lower.path(), kTestDirName);
ASSERT_THAT(mkdir(lower_dir.c_str(), 0755), SyscallSucceeds());
const std::string kCopyUpFile = "copyupfile";
std::string lower_copyup_file = JoinPath(lower.path(), kCopyUpFile);
ASSERT_NO_ERRNO(CreateWithContents(lower_copyup_file, "initial", 0644));
bool xattr_supported = true;
if (setxattr(lower_copyup_file.c_str(), "user.test", "value", 5, 0) < 0) {
if (errno == EOPNOTSUPP) {
xattr_supported = false;
} else {
ASSERT_NO_ERRNO(PosixError(errno, "setxattr failed"));
}
}
// Mount the overlay.
std::string opts = "lowerdir=" + lower.path() + ",upperdir=" + upper.path() +
",workdir=" + work.path() + ",userxattr";
ASSERT_THAT(
mount("overlay", merged.path().c_str(), "overlay", 0, opts.c_str()),
SyscallSucceeds());
auto cleanup = Cleanup([&merged] { umount2(merged.path().c_str(), 0); });
// Read the lower layer file through the overlay.
std::string merged_file = JoinPath(merged.path(), kTestFile);
std::string merged_content;
ASSERT_NO_ERRNO(GetContents(merged_file, &merged_content));
EXPECT_EQ(merged_content, kTestFileContent);
// Write a new file through the overlay and confirm it appears in the upper.
const std::string kNewFile = "newfile";
const std::string kNewFileContent = "new";
std::string new_file = JoinPath(merged.path(), kNewFile);
ASSERT_NO_ERRNO(CreateWithContents(new_file, kNewFileContent, 0644));
std::string upper_new_file = JoinPath(upper.path(), kNewFile);
std::string upper_new_content;
ASSERT_NO_ERRNO(GetContents(upper_new_file, &upper_new_content));
EXPECT_EQ(upper_new_content, kNewFileContent);
// Delete the lower layer file through the overlay and confirm it creates a
// whiteout in the upper.
ASSERT_THAT(unlink(merged_file.c_str()), SyscallSucceeds());
std::string whiteout = JoinPath(upper.path(), kTestFile);
struct stat st;
ASSERT_THAT(stat(whiteout.c_str(), &st), SyscallSucceeds());
EXPECT_TRUE(S_ISCHR(st.st_mode));
EXPECT_EQ(major(st.st_rdev), 0);
EXPECT_EQ(minor(st.st_rdev), 0);
// Delete the lower layer directory through the overlay and recreate it. This
// should mark it opaque in the upper layer.
std::string merged_dir = JoinPath(merged.path(), kTestDirName);
ASSERT_THAT(rmdir(merged_dir.c_str()), SyscallSucceeds());
ASSERT_THAT(mkdir(merged_dir.c_str(), 0755), SyscallSucceeds());
std::string upper_dir = JoinPath(upper.path(), kTestDirName);
char opaque_buf[16] = {};
ASSERT_THAT(getxattr(upper_dir.c_str(), "user.overlay.opaque", opaque_buf,
sizeof(opaque_buf)),
SyscallSucceeds());
EXPECT_EQ(opaque_buf[0], 'y');
// Test copy up on regular file.
std::string merged_copyup_file = JoinPath(merged.path(), kCopyUpFile);
ASSERT_NO_ERRNO(SetContents(merged_copyup_file, "modified"));
if (xattr_supported) {
// Confirm that the xattr is copied up with the file.
char xattr_buf[16] = {};
ASSERT_THAT(getxattr(merged_copyup_file.c_str(), "user.test", xattr_buf,
sizeof(xattr_buf)),
SyscallSucceeds());
EXPECT_STREQ(xattr_buf, "value");
}
}
TEST(MountTest, PollMountInfo) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
for (const char* path : {"/proc/self/mounts", "/proc/self/mountinfo"}) {
FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(path, O_RDONLY));
int epfd_raw = epoll_create1(0);
ASSERT_GE(epfd_raw, 0) << "epoll_create1 failed: " << strerror(errno);
FileDescriptor epfd(epfd_raw);
struct epoll_event ev = {};
ev.events = EPOLLPRI | EPOLLERR;
ev.data.fd = fd.get();
ASSERT_THAT(epoll_ctl(epfd.get(), EPOLL_CTL_ADD, fd.get(), &ev),
SyscallSucceeds());
// Drains one event and assert it has EPOLLPRI or EPOLLERR.
auto expectEvent = [&](absl::string_view label) {
struct epoll_event events[1] = {};
int nfds = epoll_wait(epfd.get(), events, 1, 0);
ASSERT_GE(nfds, 0) << label << ": epoll_wait failed: " << strerror(errno);
ASSERT_EQ(nfds, 1) << label << ": expected 1 event";
EXPECT_TRUE(events[0].events & (EPOLLPRI | EPOLLERR)) << label;
};
// Asserts no events pending.
auto expectNoEvent = [&](absl::string_view label) {
struct epoll_event events[1] = {};
int nfds = epoll_wait(epfd.get(), events, 1, 0);
ASSERT_GE(nfds, 0) << label << ": epoll_wait failed: " << strerror(errno);
EXPECT_EQ(nfds, 0) << label;
};
// Initially, there should be no events.
expectNoEvent("initial");
// mount() triggers event.
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
expectEvent("mount");
// Event is consumed by poll itself, no read needed.
expectNoEvent("after mount consumed");
// remount triggers event.
ASSERT_THAT(
mount("", dir.path().c_str(), nullptr, MS_REMOUNT | MS_RDONLY, nullptr),
SyscallSucceeds());
expectEvent("remount");
expectNoEvent("after remount consumed");
// Undo the read-only remount so umount works cleanly.
ASSERT_THAT(mount("", dir.path().c_str(), nullptr, MS_REMOUNT, nullptr),
SyscallSucceeds());
// Drain the remount-undo event.
expectEvent("remount undo");
// Umount triggers event.
mnt.Release();
ASSERT_THAT(umount2(dir.path().c_str(), 0), SyscallSucceeds());
expectEvent("umount");
expectNoEvent("after umount consumed");
// Move mount triggers event.
//
// MS_MOVE is not allowed under a MS_SHARED parent mount, so we create a
// private parent mount containing both src and dst.
auto const privateParent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
auto privateMount = ASSERT_NO_ERRNO_AND_VALUE(
Mount("", privateParent.path(), kTmpfs, 0, "", 0));
expectEvent("move setup private parent mount");
ASSERT_THAT(mount("", privateParent.path().c_str(), "", MS_PRIVATE, ""),
SyscallSucceeds());
auto const src =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(privateParent.path()));
auto const dst =
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(privateParent.path()));
auto srcMnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", src.path(), kTmpfs, 0, "", 0));
expectEvent("move setup src mount");
auto dstMnt = ASSERT_NO_ERRNO_AND_VALUE(
Mount(src.path(), dst.path(), "", MS_MOVE, "", 0));
srcMnt.Release();
expectEvent("move mount");
expectNoEvent("after move consumed");
}
}
TEST(MountTest, MountInfoAfterUnshare) {
SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));
auto const dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
for (const char* path : {"/proc/self/mounts", "/proc/self/mountinfo"}) {
int pipefd[2];
ASSERT_THAT(pipe(pipefd), SyscallSucceeds());
FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(path, O_RDONLY));
int epfd_raw = epoll_create1(0);
ASSERT_GE(epfd_raw, 0) << "epoll_create1 failed: " << strerror(errno);
FileDescriptor epfd(epfd_raw);
struct epoll_event ev = {};
ev.events = EPOLLPRI | EPOLLERR;
ev.data.fd = fd.get();
ASSERT_THAT(epoll_ctl(epfd.get(), EPOLL_CTL_ADD, fd.get(), &ev),
SyscallSucceeds());
// Initially, no events on fd.
auto expectNoEvent = [](int epfd_raw) {
struct epoll_event events[1] = {};
int nfds = epoll_wait(epfd_raw, events, 1, 0);
return nfds == 0;
};
ASSERT_TRUE(expectNoEvent(epfd.get()));
pid_t child = fork();
if (child == 0) {
close(pipefd[1]);
auto childExpectEvent = [](int epfd_raw) {
struct epoll_event events[1] = {};
int nfds = epoll_wait(epfd_raw, events, 1, 0);
TEST_PCHECK(nfds == 1);
TEST_CHECK(events[0].events & (EPOLLPRI | EPOLLERR));
};
// Unshare into a new mount namespace.
TEST_PCHECK(unshare(CLONE_NEWNS) == 0);
// Wait for the parent to perform a mount in the parent's mountns.
char c;
TEST_PCHECK(read(pipefd[0], &c, 1) == 1);
close(pipefd[0]);
// The inherited fd was opened before unshare(CLONE_NEWNS), so it should
// see the mount event from the parent's mount namespace.
childExpectEvent(epfd.get());
// Reading from the inherited fd should still give info about the old
// mount namespace (viz., where the parent mounted dir.path()).
lseek(fd.get(), 0, SEEK_SET);
char buf[65536];
size_t total = 0;
int n;
while ((total < sizeof(buf) - 1) &&
(n = read(fd.get(), buf + total, sizeof(buf) - 1 - total)) > 0) {
total += n;
}
TEST_PCHECK(n >= 0);
TEST_CHECK(absl::StrContains(absl::string_view(buf, total), dir.path()));
_exit(0);
}
close(pipefd[0]);
ASSERT_THAT(child, SyscallSucceeds());
// Perform a mount in the parent's mount namespace.
auto mnt =
ASSERT_NO_ERRNO_AND_VALUE(Mount("", dir.path(), kTmpfs, 0, "", 0));
// Notify the child that the mount is complete.
char c = 'a';
ASSERT_THAT(write(pipefd[1], &c, 1), SyscallSucceedsWithValue(1));
close(pipefd[1]);
int status;
ASSERT_THAT(waitpid(child, &status, 0), SyscallSucceedsWithValue(child));
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
}
}
} // namespace
} // namespace testing
} // namespace gvisor
Reference in New Issue View Git Blame Copy Permalink