gvisor.dev/gvisor@v0.0.0-20240520182842-f9d4d51c7e0f/test/syscalls/linux/stat_times.cc

// 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