304 lines
9.2 KiB
C++
304 lines
9.2 KiB
C++
// 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 <fcntl.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <tuple>
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "gtest/gtest.h"
|
|
#include "absl/time/clock.h"
|
|
#include "absl/time/time.h"
|
|
#include "test/util/file_descriptor.h"
|
|
#include "test/util/temp_path.h"
|
|
#include "test/util/test_util.h"
|
|
|
|
namespace gvisor {
|
|
namespace testing {
|
|
|
|
namespace {
|
|
|
|
using ::testing::IsEmpty;
|
|
using ::testing::Not;
|
|
|
|
std::tuple<absl::Time, absl::Time, absl::Time> GetTime(const TempPath& file) {
|
|
struct stat statbuf = {};
|
|
EXPECT_THAT(stat(file.path().c_str(), &statbuf), SyscallSucceeds());
|
|
|
|
const auto atime = absl::TimeFromTimespec(statbuf.st_atim);
|
|
const auto mtime = absl::TimeFromTimespec(statbuf.st_mtim);
|
|
const auto ctime = absl::TimeFromTimespec(statbuf.st_ctim);
|
|
return std::make_tuple(atime, mtime, ctime);
|
|
}
|
|
|
|
enum class AtimeEffect {
|
|
Unchanged,
|
|
Changed,
|
|
};
|
|
|
|
enum class MtimeEffect {
|
|
Unchanged,
|
|
Changed,
|
|
};
|
|
|
|
enum class CtimeEffect {
|
|
Unchanged,
|
|
Changed,
|
|
};
|
|
|
|
// Tests that fn modifies the atime/mtime/ctime of path as specified.
|
|
void CheckTimes(const TempPath& path, std::function<void()> fn,
|
|
AtimeEffect atime_effect, MtimeEffect mtime_effect,
|
|
CtimeEffect ctime_effect) {
|
|
absl::Time atime, mtime, ctime;
|
|
std::tie(atime, mtime, ctime) = GetTime(path);
|
|
|
|
// FIXME(b/132819225): gVisor filesystem timestamps inconsistently use the
|
|
// internal or host clock, which may diverge slightly. Allow some slack on
|
|
// times to account for the difference.
|
|
//
|
|
// Here we sleep for 1s so that initial creation of path doesn't fall within
|
|
// the before slack window.
|
|
absl::SleepFor(absl::Seconds(1));
|
|
|
|
const absl::Time before = absl::Now() - absl::Seconds(1);
|
|
|
|
// Perform the op.
|
|
fn();
|
|
|
|
const absl::Time after = absl::Now() + absl::Seconds(1);
|
|
|
|
absl::Time atime2, mtime2, ctime2;
|
|
std::tie(atime2, mtime2, ctime2) = GetTime(path);
|
|
|
|
if (atime_effect == AtimeEffect::Changed) {
|
|
EXPECT_LE(before, atime2);
|
|
EXPECT_GE(after, atime2);
|
|
EXPECT_GT(atime2, atime);
|
|
} else {
|
|
EXPECT_EQ(atime2, atime);
|
|
}
|
|
|
|
if (mtime_effect == MtimeEffect::Changed) {
|
|
EXPECT_LE(before, mtime2);
|
|
EXPECT_GE(after, mtime2);
|
|
EXPECT_GT(mtime2, mtime);
|
|
} else {
|
|
EXPECT_EQ(mtime2, mtime);
|
|
}
|
|
|
|
if (ctime_effect == CtimeEffect::Changed) {
|
|
EXPECT_LE(before, ctime2);
|
|
EXPECT_GE(after, ctime2);
|
|
EXPECT_GT(ctime2, ctime);
|
|
} else {
|
|
EXPECT_EQ(ctime2, ctime);
|
|
}
|
|
}
|
|
|
|
// File creation time is reflected in atime, mtime, and ctime.
|
|
TEST(StatTimesTest, FileCreation) {
|
|
const DisableSave ds; // Timing-related test.
|
|
|
|
// Get a time for when the file is created.
|
|
//
|
|
// FIXME(b/132819225): See above.
|
|
const absl::Time before = absl::Now() - absl::Seconds(1);
|
|
const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
const absl::Time after = absl::Now() + absl::Seconds(1);
|
|
|
|
absl::Time atime, mtime, ctime;
|
|
std::tie(atime, mtime, ctime) = GetTime(file);
|
|
|
|
EXPECT_LE(before, atime);
|
|
EXPECT_LE(before, mtime);
|
|
EXPECT_LE(before, ctime);
|
|
EXPECT_GE(after, atime);
|
|
EXPECT_GE(after, mtime);
|
|
EXPECT_GE(after, ctime);
|
|
}
|
|
|
|
// Calling chmod on a file changes ctime.
|
|
TEST(StatTimesTest, FileChmod) {
|
|
TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
auto fn = [&] {
|
|
EXPECT_THAT(chmod(file.path().c_str(), 0666), SyscallSucceeds());
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Unchanged, MtimeEffect::Unchanged,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Renaming a file changes ctime.
|
|
TEST(StatTimesTest, FileRename) {
|
|
TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
const std::string newpath = NewTempAbsPath();
|
|
|
|
auto fn = [&] {
|
|
ASSERT_THAT(rename(file.release().c_str(), newpath.c_str()),
|
|
SyscallSucceeds());
|
|
file.reset(newpath);
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Unchanged, MtimeEffect::Unchanged,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Renaming a file changes ctime, even with an open FD.
|
|
//
|
|
// NOTE(b/132732387): This is a regression test for fs/gofer failing to update
|
|
// cached ctime.
|
|
TEST(StatTimesTest, FileRenameOpenFD) {
|
|
TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Holding an FD shouldn't affect behavior.
|
|
const FileDescriptor fd =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDONLY));
|
|
|
|
const std::string newpath = NewTempAbsPath();
|
|
|
|
// FIXME(b/132814682): Restore fails with an uncached gofer and an open FD
|
|
// across rename.
|
|
//
|
|
// N.B. The logic here looks backwards because it isn't possible to
|
|
// conditionally disable save, only conditionally re-enable it.
|
|
DisableSave ds;
|
|
if (!getenv("GVISOR_GOFER_UNCACHED")) {
|
|
ds.reset();
|
|
}
|
|
|
|
auto fn = [&] {
|
|
ASSERT_THAT(rename(file.release().c_str(), newpath.c_str()),
|
|
SyscallSucceeds());
|
|
file.reset(newpath);
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Unchanged, MtimeEffect::Unchanged,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Calling utimes on a file changes ctime and the time that we ask to change
|
|
// (atime to now in this case).
|
|
TEST(StatTimesTest, FileUtimes) {
|
|
TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
auto fn = [&] {
|
|
const struct timespec ts[2] = {{0, UTIME_NOW}, {0, UTIME_OMIT}};
|
|
ASSERT_THAT(utimensat(AT_FDCWD, file.path().c_str(), ts, 0),
|
|
SyscallSucceeds());
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Changed, MtimeEffect::Unchanged,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Truncating a file changes mtime and ctime.
|
|
TEST(StatTimesTest, FileTruncate) {
|
|
const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(
|
|
TempPath::CreateFileWith(GetAbsoluteTestTmpdir(), "yaaass", 0666));
|
|
|
|
auto fn = [&] {
|
|
EXPECT_THAT(truncate(file.path().c_str(), 0), SyscallSucceeds());
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Unchanged, MtimeEffect::Changed,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Writing a file changes mtime and ctime.
|
|
TEST(StatTimesTest, FileWrite) {
|
|
const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(
|
|
TempPath::CreateFileWith(GetAbsoluteTestTmpdir(), "yaaass", 0666));
|
|
|
|
const FileDescriptor fd =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR, 0));
|
|
|
|
auto fn = [&] {
|
|
const std::string contents = "all the single dollars";
|
|
EXPECT_THAT(WriteFd(fd.get(), contents.data(), contents.size()),
|
|
SyscallSucceeds());
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Unchanged, MtimeEffect::Changed,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Reading a file changes atime.
|
|
TEST(StatTimesTest, FileRead) {
|
|
const std::string contents = "bills bills bills";
|
|
const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(
|
|
TempPath::CreateFileWith(GetAbsoluteTestTmpdir(), contents, 0666));
|
|
|
|
const FileDescriptor fd =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDONLY, 0));
|
|
|
|
auto fn = [&] {
|
|
char buf[20];
|
|
ASSERT_THAT(ReadFd(fd.get(), buf, sizeof(buf)),
|
|
SyscallSucceedsWithValue(contents.size()));
|
|
};
|
|
CheckTimes(file, fn, AtimeEffect::Changed, MtimeEffect::Unchanged,
|
|
CtimeEffect::Unchanged);
|
|
}
|
|
|
|
// Listing files in a directory changes atime.
|
|
TEST(StatTimesTest, DirList) {
|
|
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
|
|
const TempPath file =
|
|
ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path()));
|
|
|
|
auto fn = [&] {
|
|
const auto contents = ASSERT_NO_ERRNO_AND_VALUE(ListDir(dir.path(), false));
|
|
EXPECT_THAT(contents, Not(IsEmpty()));
|
|
};
|
|
CheckTimes(dir, fn, AtimeEffect::Changed, MtimeEffect::Unchanged,
|
|
CtimeEffect::Unchanged);
|
|
}
|
|
|
|
// Creating a file in a directory changes mtime and ctime.
|
|
TEST(StatTimesTest, DirCreateFile) {
|
|
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
|
|
|
|
TempPath file;
|
|
auto fn = [&] {
|
|
file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path()));
|
|
};
|
|
CheckTimes(dir, fn, AtimeEffect::Unchanged, MtimeEffect::Changed,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Creating a directory in a directory changes mtime and ctime.
|
|
TEST(StatTimesTest, DirCreateDir) {
|
|
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
|
|
|
|
TempPath dir2;
|
|
auto fn = [&] {
|
|
dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(dir.path()));
|
|
};
|
|
CheckTimes(dir, fn, AtimeEffect::Unchanged, MtimeEffect::Changed,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
// Removing a file from a directory changes mtime and ctime.
|
|
TEST(StatTimesTest, DirRemoveFile) {
|
|
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
|
|
|
|
TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path()));
|
|
auto fn = [&] { file.reset(); };
|
|
CheckTimes(dir, fn, AtimeEffect::Unchanged, MtimeEffect::Changed,
|
|
CtimeEffect::Changed);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
} // namespace testing
|
|
} // namespace gvisor
|