// 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 <libgen.h> #include <sched.h> #include <sys/epoll.h> #include <sys/inotify.h> #include <sys/ioctl.h> #include <sys/sendfile.h> #include <sys/time.h> #include <sys/xattr.h> #include <atomic> #include <list> #include <string> #include <vector> #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/str_join.h" #include "absl/synchronization/mutex.h" #include "absl/time/clock.h" #include "absl/time/time.h" #include "test/util/epoll_util.h" #include "test/util/file_descriptor.h" #include "test/util/fs_util.h" #include "test/util/multiprocess_util.h" #include "test/util/posix_error.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 ::absl::StreamFormat; using ::absl::StrFormat; constexpr int kBufSize = 1024; // C++-friendly version of struct inotify_event. struct Event { int32_t wd; uint32_t mask; uint32_t cookie; uint32_t len; std::string name; Event(uint32_t mask, int32_t wd, absl::string_view name, uint32_t cookie) : wd(wd), mask(mask), cookie(cookie), len(name.size()), name(std::string(name)) {} Event(uint32_t mask, int32_t wd, absl::string_view name) : Event(mask, wd, name, 0) {} Event(uint32_t mask, int32_t wd) : Event(mask, wd, "", 0) {} Event() : Event(0, 0, "", 0) {} }; // Prints the symbolic name for a struct inotify_event's 'mask' field. std::string FlagString(uint32_t flags) { std::vector<std::string> names; #define EMIT(target) \ if (flags & target) { \ names.push_back(#target); \ flags &= ~target; \ } EMIT(IN_ACCESS); EMIT(IN_ATTRIB); EMIT(IN_CLOSE_WRITE); EMIT(IN_CLOSE_NOWRITE); EMIT(IN_CREATE); EMIT(IN_DELETE); EMIT(IN_DELETE_SELF); EMIT(IN_MODIFY); EMIT(IN_MOVE_SELF); EMIT(IN_MOVED_FROM); EMIT(IN_MOVED_TO); EMIT(IN_OPEN); EMIT(IN_DONT_FOLLOW); EMIT(IN_EXCL_UNLINK); EMIT(IN_ONESHOT); EMIT(IN_ONLYDIR); EMIT(IN_IGNORED); EMIT(IN_ISDIR); EMIT(IN_Q_OVERFLOW); EMIT(IN_UNMOUNT); #undef EMIT // If we have anything left over at the end, print it as a hex value. if (flags) { names.push_back(absl::StrCat("0x", absl::Hex(flags))); } return absl::StrJoin(names, "|"); } std::string DumpEvent(const Event& event) { return StrFormat( "%s, wd=%d%s%s", FlagString(event.mask), event.wd, (event.len > 0) ? StrFormat(", name=%s", event.name) : "", (event.cookie > 0) ? StrFormat(", cookie=%ud", event.cookie) : ""); } std::string DumpEvents(const std::vector<Event>& events, int indent_level) { std::stringstream ss; ss << StreamFormat("%d event%s:\n", events.size(), (events.size() > 1) ? "s" : ""); int i = 0; for (const Event& ev : events) { ss << StreamFormat("%sevents[%d]: %s\n", std::string(indent_level, '\t'), i++, DumpEvent(ev)); } return ss.str(); } // A matcher which takes an expected list of events to match against another // list of inotify events, in order. This is similar to the ElementsAre matcher, // but displays more informative messages on mismatch. class EventsAreMatcher : public ::testing::MatcherInterface<std::vector<Event>> { public: explicit EventsAreMatcher(std::vector<Event> references) : references_(std::move(references)) {} bool MatchAndExplain( std::vector<Event> events, ::testing::MatchResultListener* const listener) const override { if (references_.size() != events.size()) { *listener << StreamFormat("\n\tCount mismatch, got %s", DumpEvents(events, 2)); return false; } bool success = true; for (unsigned int i = 0; i < references_.size(); ++i) { const Event& reference = references_[i]; const Event& target = events[i]; if (target.mask != reference.mask || target.wd != reference.wd || target.name != reference.name || target.cookie != reference.cookie) { *listener << StreamFormat("\n\tMismatch at index %d, want %s, got %s,", i, DumpEvent(reference), DumpEvent(target)); success = false; } } if (!success) { *listener << StreamFormat("\n\tIn total of %s", DumpEvents(events, 2)); } return success; } void DescribeTo(::std::ostream* const os) const override { *os << StreamFormat("%s", DumpEvents(references_, 1)); } void DescribeNegationTo(::std::ostream* const os) const override { *os << StreamFormat("mismatch from %s", DumpEvents(references_, 1)); } private: std::vector<Event> references_; }; ::testing::Matcher<std::vector<Event>> Are(std::vector<Event> events) { return MakeMatcher(new EventsAreMatcher(std::move(events))); } // Similar to the EventsAre matcher, but the order of events are ignored. class UnorderedEventsAreMatcher : public ::testing::MatcherInterface<std::vector<Event>> { public: explicit UnorderedEventsAreMatcher(std::vector<Event> references) : references_(std::move(references)) {} bool MatchAndExplain( std::vector<Event> events, ::testing::MatchResultListener* const listener) const override { if (references_.size() != events.size()) { *listener << StreamFormat("\n\tCount mismatch, got %s", DumpEvents(events, 2)); return false; } std::vector<Event> unmatched(references_); for (const Event& candidate : events) { for (auto it = unmatched.begin(); it != unmatched.end();) { const Event& reference = *it; if (candidate.mask == reference.mask && candidate.wd == reference.wd && candidate.name == reference.name && candidate.cookie == reference.cookie) { it = unmatched.erase(it); break; } else { ++it; } } } // Anything left unmatched? If so, the matcher fails. if (!unmatched.empty()) { *listener << StreamFormat("\n\tFailed to match %s", DumpEvents(unmatched, 2)); *listener << StreamFormat("\n\tIn total of %s", DumpEvents(events, 2)); return false; } return true; } void DescribeTo(::std::ostream* const os) const override { *os << StreamFormat("unordered %s", DumpEvents(references_, 1)); } void DescribeNegationTo(::std::ostream* const os) const override { *os << StreamFormat("mismatch from unordered %s", DumpEvents(references_, 1)); } private: std::vector<Event> references_; }; ::testing::Matcher<std::vector<Event>> AreUnordered(std::vector<Event> events) { return MakeMatcher(new UnorderedEventsAreMatcher(std::move(events))); } // Reads events from an inotify fd until either EOF, or read returns EAGAIN. PosixErrorOr<std::vector<Event>> DrainEvents(int fd) { std::vector<Event> events; while (true) { int events_size = 0; if (ioctl(fd, FIONREAD, &events_size) < 0) { return PosixError(errno, "ioctl(FIONREAD) failed on inotify fd"); } // Deliberately use a buffer that is larger than necessary, expecting to // only read events_size bytes. std::vector<char> buf(events_size + kBufSize, 0); const ssize_t readlen = read(fd, buf.data(), buf.size()); MaybeSave(); // Read error? if (readlen < 0) { if (errno == EAGAIN) { // If EAGAIN, no more events at the moment. Return what we have so far. return events; } // Some other read error. Return an error. Right now if we encounter this // after already reading some events, they get lost. However, we don't // expect to see any error, and the calling test will fail immediately if // we signal an error anyways, so this is acceptable. return PosixError(errno, "read() failed on inotify fd"); } if (readlen < static_cast<int>(sizeof(struct inotify_event))) { // Impossibly short read. return PosixError( EIO, "read() didn't return enough data represent even a single event"); } if (readlen != events_size) { return PosixError(EINVAL, absl::StrCat("read ", readlen, " bytes, expected ", events_size)); } if (readlen == 0) { // EOF. return events; } // Normal read. const char* cursor = buf.data(); while (cursor < (buf.data() + readlen)) { struct inotify_event event = {}; memcpy(&event, cursor, sizeof(struct inotify_event)); Event ev; ev.wd = event.wd; ev.mask = event.mask; ev.cookie = event.cookie; ev.len = event.len; if (event.len > 0) { TEST_CHECK(static_cast<int>(sizeof(struct inotify_event) + event.len) <= readlen); ev.name = std::string(cursor + offsetof(struct inotify_event, name)); // NOLINT // Name field should always be smaller than event.len, otherwise we have // a buffer overflow. The two sizes aren't equal because the string // constructor will stop at the first null byte, while event.name may be // padded up to event.len using multiple null bytes. TEST_CHECK(ev.name.size() <= event.len); } events.push_back(ev); cursor += sizeof(struct inotify_event) + event.len; } } } PosixErrorOr<FileDescriptor> InotifyInit1(int flags) { int fd = inotify_init1(flags); if (fd < 0) { return PosixError(errno, "inotify_init1() failed"); } return FileDescriptor(fd); } PosixErrorOr<int> InotifyAddWatch(int fd, const std::string& path, uint32_t mask) { int wd = inotify_add_watch(fd, path.c_str(), mask); if (wd < 0) { return PosixError(errno, "inotify_add_watch() failed"); } return wd; } TEST(Inotify, IllegalSeek) { const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(0)); EXPECT_THAT(lseek(fd.get(), 0, SEEK_SET), SyscallFailsWithErrno(ESPIPE)); } TEST(Inotify, IllegalPread) { const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(0)); int val; EXPECT_THAT(pread(fd.get(), &val, sizeof(val), 0), SyscallFailsWithErrno(ESPIPE)); } TEST(Inotify, IllegalPwrite) { const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(0)); EXPECT_THAT(pwrite(fd.get(), "x", 1, 0), SyscallFailsWithErrno(ESPIPE)); } TEST(Inotify, IllegalWrite) { const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(0)); int val = 0; EXPECT_THAT(write(fd.get(), &val, sizeof(val)), SyscallFailsWithErrno(EBADF)); } TEST(Inotify, InitFlags) { EXPECT_THAT(inotify_init1(IN_NONBLOCK | IN_CLOEXEC), SyscallSucceeds()); EXPECT_THAT(inotify_init1(12345), SyscallFailsWithErrno(EINVAL)); } TEST(Inotify, NonBlockingReadReturnsEagain) { const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); std::vector<char> buf(kBufSize, 0); // The read below should return fail with EAGAIN because there is no data to // read and we've specified IN_NONBLOCK. We're guaranteed that there is no // data to read because we haven't registered any watches yet. EXPECT_THAT(read(fd.get(), buf.data(), buf.size()), SyscallFailsWithErrno(EAGAIN)); } TEST(Inotify, AddWatchOnInvalidFdFails) { // Garbage fd. EXPECT_THAT(inotify_add_watch(-1, "/tmp", IN_ALL_EVENTS), SyscallFailsWithErrno(EBADF)); EXPECT_THAT(inotify_add_watch(1337, "/tmp", IN_ALL_EVENTS), SyscallFailsWithErrno(EBADF)); // Non-inotify fds. EXPECT_THAT(inotify_add_watch(0, "/tmp", IN_ALL_EVENTS), SyscallFailsWithErrno(EINVAL)); EXPECT_THAT(inotify_add_watch(1, "/tmp", IN_ALL_EVENTS), SyscallFailsWithErrno(EINVAL)); EXPECT_THAT(inotify_add_watch(2, "/tmp", IN_ALL_EVENTS), SyscallFailsWithErrno(EINVAL)); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open("/tmp", O_RDONLY)); EXPECT_THAT(inotify_add_watch(fd.get(), "/tmp", IN_ALL_EVENTS), SyscallFailsWithErrno(EINVAL)); } TEST(Inotify, RemovingWatchGeneratesEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); EXPECT_THAT(inotify_rm_watch(fd.get(), wd), SyscallSucceeds()); // Read events, ensure the first event is IN_IGNORED. const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_THAT(events, Are({Event(IN_IGNORED, wd)})); } TEST(Inotify, CanDeleteFileAfterRemovingWatch) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); EXPECT_THAT(inotify_rm_watch(fd.get(), wd), SyscallSucceeds()); file1.reset(); } TEST(Inotify, RemoveWatchAfterDeletingFileFails) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); file1.reset(); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_THAT(events, Are({Event(IN_ATTRIB, wd), Event(IN_DELETE_SELF, wd), Event(IN_IGNORED, wd)})); EXPECT_THAT(inotify_rm_watch(fd.get(), wd), SyscallFailsWithErrno(EINVAL)); } TEST(Inotify, DuplicateWatchRemovalFails) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); EXPECT_THAT(inotify_rm_watch(fd.get(), wd), SyscallSucceeds()); EXPECT_THAT(inotify_rm_watch(fd.get(), wd), SyscallFailsWithErrno(EINVAL)); } TEST(Inotify, ConcurrentFileDeletionAndWatchRemoval) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const std::string filename = NewTempAbsPathInDir(root.path()); auto file_create_delete = [filename]() { const DisableSave ds; // Too expensive. for (int i = 0; i < 100; ++i) { FileDescriptor file_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(filename, O_CREAT, S_IRUSR | S_IWUSR)); // Close before unlinking (although S/R is disabled). Some filesystems // cannot restore an open fd on an unlinked file. file_fd.reset(); EXPECT_THAT(unlink(filename.c_str()), SyscallSucceeds()); } }; const int shared_fd = fd.get(); // We need to pass it to the thread. auto add_remove_watch = [shared_fd, filename]() { for (int i = 0; i < 100; ++i) { int wd = inotify_add_watch(shared_fd, filename.c_str(), IN_ALL_EVENTS); MaybeSave(); if (wd != -1) { // Watch added successfully, try removal. if (inotify_rm_watch(shared_fd, wd)) { // If removal fails, the only acceptable reason is if the wd // is invalid, which will be the case if we try to remove // the watch after the file has been deleted. EXPECT_EQ(errno, EINVAL); } } else { // Add watch failed, this should only fail if the target file doesn't // exist. EXPECT_EQ(errno, ENOENT); } } }; ScopedThread t1(file_create_delete); ScopedThread t2(add_remove_watch); } TEST(Inotify, DeletingChildGeneratesEvents) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); const std::string file1_path = file1.reset(); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, AreUnordered({Event(IN_ATTRIB, file1_wd), Event(IN_DELETE_SELF, file1_wd), Event(IN_IGNORED, file1_wd), Event(IN_DELETE, root_wd, Basename(file1_path))})); } // Creating a file in "parent/child" should generate events for child, but not // parent. TEST(Inotify, CreatingFileGeneratesEvents) { const TempPath parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath child = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), parent.path(), IN_ALL_EVENTS)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), child.path(), IN_ALL_EVENTS)); // Create a new file in the directory. const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(child.path())); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); // The library function we use to create the new file opens it for writing to // create it and sets permissions on it, so we expect the three extra events. ASSERT_THAT(events, Are({Event(IN_CREATE, wd, Basename(file1.path())), Event(IN_OPEN, wd, Basename(file1.path())), Event(IN_CLOSE_WRITE, wd, Basename(file1.path())), Event(IN_ATTRIB, wd, Basename(file1.path()))})); } TEST(Inotify, ReadingFileGeneratesAccessEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); char buf; EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_ACCESS, wd, Basename(file1.path()))})); } TEST(Inotify, WritingFileGeneratesModifyEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_WRONLY)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const std::string data = "some content"; EXPECT_THAT(write(file1_fd.get(), data.c_str(), data.length()), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_MODIFY, wd, Basename(file1.path()))})); } TEST(Inotify, SizeZeroReadWriteGeneratesNothing) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDWR)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); // Read from the empty file. int val; ASSERT_THAT(read(file1_fd.get(), &val, sizeof(val)), SyscallSucceedsWithValue(0)); // Write zero bytes. ASSERT_THAT(write(file1_fd.get(), "", 0), SyscallSucceedsWithValue(0)); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({})); } TEST(Inotify, FailedFileCreationGeneratesNoEvents) { const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const std::string dir_path = dir.path(); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch(fd.get(), dir_path, IN_ALL_EVENTS)); const char* p = dir_path.c_str(); ASSERT_THAT(mkdir(p, 0777), SyscallFails()); ASSERT_THAT(mknod(p, S_IFIFO, 0777), SyscallFails()); ASSERT_THAT(symlink(p, p), SyscallFails()); ASSERT_THAT(link(p, p), SyscallFails()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({})); } TEST(Inotify, WatchSetAfterOpenReportsCloseFdEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); FileDescriptor file1_fd_writable = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_WRONLY)); FileDescriptor file1_fd_not_writable = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); file1_fd_writable.reset(); // Close file1_fd_writable. std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_CLOSE_WRITE, wd, Basename(file1.path()))})); file1_fd_not_writable.reset(); // Close file1_fd_not_writable. events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_CLOSE_NOWRITE, wd, Basename(file1.path()))})); } TEST(Inotify, ChildrenDeletionInWatchedDirGeneratesEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); TempPath dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(root.path())); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const std::string file1_path = file1.reset(); const std::string dir1_path = dir1.release(); EXPECT_THAT(rmdir(dir1_path.c_str()), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_DELETE, wd, Basename(file1_path)), Event(IN_DELETE | IN_ISDIR, wd, Basename(dir1_path))})); } TEST(Inotify, RmdirOnWatchedTargetGeneratesEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); EXPECT_THAT(rmdir(root.path().c_str()), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_DELETE_SELF, wd), Event(IN_IGNORED, wd)})); } TEST(Inotify, MoveGeneratesEvents) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const TempPath dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(root.path())); const TempPath dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(root.path())); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int dir1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), dir1.path(), IN_ALL_EVENTS)); const int dir2_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), dir2.path(), IN_ALL_EVENTS)); // Test move from root -> root. std::string newpath = NewTempAbsPathInDir(root.path()); std::string oldpath = file1.release(); EXPECT_THAT(rename(oldpath.c_str(), newpath.c_str()), SyscallSucceeds()); file1.reset(newpath); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, Are({Event(IN_MOVED_FROM, root_wd, Basename(oldpath), events[0].cookie), Event(IN_MOVED_TO, root_wd, Basename(newpath), events[1].cookie)})); EXPECT_NE(events[0].cookie, 0); EXPECT_EQ(events[0].cookie, events[1].cookie); uint32_t last_cookie = events[0].cookie; // Test move from root -> root/dir1. newpath = NewTempAbsPathInDir(dir1.path()); oldpath = file1.release(); EXPECT_THAT(rename(oldpath.c_str(), newpath.c_str()), SyscallSucceeds()); file1.reset(newpath); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, Are({Event(IN_MOVED_FROM, root_wd, Basename(oldpath), events[0].cookie), Event(IN_MOVED_TO, dir1_wd, Basename(newpath), events[1].cookie)})); // Cookies should be distinct between distinct rename events. EXPECT_NE(events[0].cookie, last_cookie); EXPECT_EQ(events[0].cookie, events[1].cookie); last_cookie = events[0].cookie; // Test move from root/dir1 -> root/dir2. newpath = NewTempAbsPathInDir(dir2.path()); oldpath = file1.release(); EXPECT_THAT(rename(oldpath.c_str(), newpath.c_str()), SyscallSucceeds()); file1.reset(newpath); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, Are({Event(IN_MOVED_FROM, dir1_wd, Basename(oldpath), events[0].cookie), Event(IN_MOVED_TO, dir2_wd, Basename(newpath), events[1].cookie)})); EXPECT_NE(events[0].cookie, last_cookie); EXPECT_EQ(events[0].cookie, events[1].cookie); last_cookie = events[0].cookie; } TEST(Inotify, MoveWatchedTargetGeneratesEvents) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); const std::string newpath = NewTempAbsPathInDir(root.path()); const std::string oldpath = file1.release(); EXPECT_THAT(rename(oldpath.c_str(), newpath.c_str()), SyscallSucceeds()); file1.reset(newpath); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, Are({Event(IN_MOVED_FROM, root_wd, Basename(oldpath), events[0].cookie), Event(IN_MOVED_TO, root_wd, Basename(newpath), events[1].cookie), // Self move events do not have a cookie. Event(IN_MOVE_SELF, file1_wd)})); EXPECT_NE(events[0].cookie, 0); EXPECT_EQ(events[0].cookie, events[1].cookie); } // Tests that close events are only emitted when a file description drops its // last reference. TEST(Inotify, DupFD) { SKIP_IF(IsRunningWithVFS1()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile()); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), file.path(), IN_ALL_EVENTS)); FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDONLY)); FileDescriptor fd2 = ASSERT_NO_ERRNO_AND_VALUE(fd.Dup()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_OPEN, wd), })); fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({})); fd2.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_CLOSE_NOWRITE, wd), })); } TEST(Inotify, CoalesceEvents) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); // Read the file a few times. This will would generate multiple IN_ACCESS // events but they should get coalesced to a single event. char buf; EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); // Use the close event verify that we haven't simply left the additional // IN_ACCESS events unread. file1_fd.reset(); // Close file1_fd. const std::string file1_name = std::string(Basename(file1.path())); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_ACCESS, wd, file1_name), Event(IN_CLOSE_NOWRITE, wd, file1_name)})); // Now let's try interleaving other events into a stream of repeated events. file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDWR)); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(write(file1_fd.get(), "x", 1), SyscallSucceeds()); EXPECT_THAT(write(file1_fd.get(), "x", 1), SyscallSucceeds()); EXPECT_THAT(write(file1_fd.get(), "x", 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); file1_fd.reset(); // Close the file. events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, Are({Event(IN_OPEN, wd, file1_name), Event(IN_ACCESS, wd, file1_name), Event(IN_MODIFY, wd, file1_name), Event(IN_ACCESS, wd, file1_name), Event(IN_CLOSE_WRITE, wd, file1_name)})); // Ensure events aren't coalesced if they are from different files. const TempPath file2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); // Discard events resulting from creation of file2. ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); FileDescriptor file2_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file2.path(), O_RDONLY)); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file2_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); // Close both files. file1_fd.reset(); file2_fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); const std::string file2_name = std::string(Basename(file2.path())); ASSERT_THAT( events, Are({Event(IN_OPEN, wd, file1_name), Event(IN_OPEN, wd, file2_name), Event(IN_ACCESS, wd, file1_name), Event(IN_ACCESS, wd, file2_name), Event(IN_ACCESS, wd, file1_name), Event(IN_CLOSE_NOWRITE, wd, file1_name), Event(IN_CLOSE_NOWRITE, wd, file2_name)})); } TEST(Inotify, ClosingInotifyFdWithoutRemovingWatchesWorks) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); // Note: The check on close will happen in FileDescriptor::~FileDescriptor(). } TEST(Inotify, NestedWatches) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); // Read from file1. This should generate an event for both watches. char buf; EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_ACCESS, root_wd, Basename(file1.path())), Event(IN_ACCESS, file1_wd)})); } TEST(Inotify, ConcurrentThreadsGeneratingEvents) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); std::vector<TempPath> files; files.reserve(10); for (int i = 0; i < 10; i++) { files.emplace_back(ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode))); } auto test_thread = [&files]() { uint32_t seed = time(nullptr); for (int i = 0; i < 20; i++) { const TempPath& file = files[rand_r(&seed) % files.size()]; const FileDescriptor file_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_WRONLY)); TEST_PCHECK(write(file_fd.get(), "x", 1) == 1); } }; ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); std::list<ScopedThread> threads; for (int i = 0; i < 3; i++) { threads.emplace_back(test_thread); } for (auto& t : threads) { t.Join(); } const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); // 3 threads doing 20 iterations, 3 events per iteration (open, write, // close). However, some events may be coalesced, and we can't reliably // predict how they'll be coalesced since the test threads aren't // synchronized. We can only check that we aren't getting unexpected events. for (const Event& ev : events) { EXPECT_NE(ev.mask & (IN_OPEN | IN_MODIFY | IN_CLOSE_WRITE), 0); } } TEST(Inotify, ReadWithTooSmallBufferFails) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); // Open the file to queue an event. This event will not have a filename, so // reading from the inotify fd should return sizeof(struct inotify_event) // bytes of data. FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); std::vector<char> buf(kBufSize, 0); ssize_t readlen; // Try a buffer too small to hold any potential event. This is rejected // outright without the event being dequeued. EXPECT_THAT(read(fd.get(), buf.data(), sizeof(struct inotify_event) - 1), SyscallFailsWithErrno(EINVAL)); // Try a buffer just large enough. This should succeeed. EXPECT_THAT( readlen = read(fd.get(), buf.data(), sizeof(struct inotify_event)), SyscallSucceeds()); EXPECT_EQ(readlen, sizeof(struct inotify_event)); // Event queue is now empty, the next read should return EAGAIN. EXPECT_THAT(read(fd.get(), buf.data(), sizeof(struct inotify_event)), SyscallFailsWithErrno(EAGAIN)); // Now put a watch on the directory, so that generated events contain a name. EXPECT_THAT(inotify_rm_watch(fd.get(), wd), SyscallSucceeds()); // Drain the event generated from the watch removal. ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); file1_fd.reset(); // Close file to generate an event. // Try a buffer too small to hold any event and one too small to hold an event // with a name. These should both fail without consuming the event. EXPECT_THAT(read(fd.get(), buf.data(), sizeof(struct inotify_event) - 1), SyscallFailsWithErrno(EINVAL)); EXPECT_THAT(read(fd.get(), buf.data(), sizeof(struct inotify_event)), SyscallFailsWithErrno(EINVAL)); // Now try with a large enough buffer. This should return the one event. EXPECT_THAT(readlen = read(fd.get(), buf.data(), buf.size()), SyscallSucceeds()); EXPECT_GE(readlen, sizeof(struct inotify_event) + Basename(file1.path()).size()); // With the single event read, the queue should once again be empty. EXPECT_THAT(read(fd.get(), buf.data(), sizeof(struct inotify_event)), SyscallFailsWithErrno(EAGAIN)); } TEST(Inotify, BlockingReadOnInotifyFd) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(0)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); // Spawn a thread performing a blocking read for new events on the inotify fd. std::vector<char> buf(kBufSize, 0); const int shared_fd = fd.get(); // The thread needs it. ScopedThread t([shared_fd, &buf]() { ssize_t readlen; EXPECT_THAT(readlen = read(shared_fd, buf.data(), buf.size()), SyscallSucceeds()); }); // Perform a read on the watched file, which should generate an IN_ACCESS // event, unblocking the event_reader thread. char c; EXPECT_THAT(read(file1_fd.get(), &c, 1), SyscallSucceeds()); // Wait for the thread to read the event and exit. t.Join(); // Make sure the event we got back is sane. uint32_t event_mask; memcpy(&event_mask, buf.data() + offsetof(struct inotify_event, mask), sizeof(event_mask)); EXPECT_EQ(event_mask, IN_ACCESS); } TEST(Inotify, WatchOnRelativePath) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); // Change working directory to root. const FileDescriptor cwd = ASSERT_NO_ERRNO_AND_VALUE(Open(".", O_PATH)); EXPECT_THAT(chdir(root.path().c_str()), SyscallSucceeds()); // Add a watch on file1 with a relative path. const int wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( fd.get(), std::string(Basename(file1.path())), IN_ALL_EVENTS)); // Perform a read on file1, this should generate an IN_ACCESS event. char c; EXPECT_THAT(read(file1_fd.get(), &c, 1), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_THAT(events, Are({Event(IN_ACCESS, wd)})); // Explicitly reset the working directory so that we don't continue to // reference "root". Once the test ends, "root" will get unlinked. If we // continue to hold a reference, random save/restore tests can fail if a save // is triggered after "root" is unlinked; we can't save deleted fs objects // with active references. EXPECT_THAT(fchdir(cwd.get()), SyscallSucceeds()); } TEST(Inotify, ZeroLengthReadWriteDoesNotGenerateEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const char kContent[] = "some content"; TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), kContent, TempPath::kDefaultFileMode)); const int kContentSize = sizeof(kContent) - 1; const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDWR)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); std::vector<char> buf(kContentSize, 0); // Read all available data. ssize_t readlen; EXPECT_THAT(readlen = read(file1_fd.get(), buf.data(), kContentSize), SyscallSucceeds()); EXPECT_EQ(readlen, kContentSize); // Drain all events and make sure we got the IN_ACCESS for the read. std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_THAT(events, Are({Event(IN_ACCESS, wd, Basename(file1.path()))})); // Now try read again. This should be a 0-length read, since we're at EOF. char c; EXPECT_THAT(readlen = read(file1_fd.get(), &c, 1), SyscallSucceeds()); EXPECT_EQ(readlen, 0); // We should have no new events. events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_TRUE(events.empty()); // Try issuing a zero-length read. EXPECT_THAT(readlen = read(file1_fd.get(), &c, 0), SyscallSucceeds()); EXPECT_EQ(readlen, 0); // We should have no new events. events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_TRUE(events.empty()); // Try issuing a zero-length write. ssize_t writelen; EXPECT_THAT(writelen = write(file1_fd.get(), &c, 0), SyscallSucceeds()); EXPECT_EQ(writelen, 0); // We should have no new events. events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_TRUE(events.empty()); } TEST(Inotify, ChmodGeneratesAttribEvent_NoRandomSave) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); FileDescriptor root_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(root.path(), O_RDONLY)); FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDWR)); FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); auto verify_chmod_events = [&]() { std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_ATTRIB, root_wd, Basename(file1.path())), Event(IN_ATTRIB, file1_wd)})); }; // Don't do cooperative S/R tests for any of the {f}chmod* syscalls below, the // test will always fail because nodes cannot be saved when they have stricter // permissions than the original host node. const DisableSave ds; // Chmod. ASSERT_THAT(chmod(file1.path().c_str(), S_IWGRP), SyscallSucceeds()); verify_chmod_events(); // Fchmod. ASSERT_THAT(fchmod(file1_fd.get(), S_IRGRP | S_IWGRP), SyscallSucceeds()); verify_chmod_events(); // Fchmodat. const std::string file1_basename = std::string(Basename(file1.path())); ASSERT_THAT(fchmodat(root_fd.get(), file1_basename.c_str(), S_IWGRP, 0), SyscallSucceeds()); verify_chmod_events(); // Make sure the chmod'ed file descriptors are destroyed before DisableSave // is destructed. root_fd.reset(); file1_fd.reset(); } TEST(Inotify, TruncateGeneratesModifyEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDWR)); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); auto verify_truncate_events = [&]() { std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_MODIFY, root_wd, Basename(file1.path())), Event(IN_MODIFY, file1_wd)})); }; // Truncate. EXPECT_THAT(truncate(file1.path().c_str(), 4096), SyscallSucceeds()); verify_truncate_events(); // Ftruncate. EXPECT_THAT(ftruncate(file1_fd.get(), 8192), SyscallSucceeds()); verify_truncate_events(); // No events if truncate fails. EXPECT_THAT(ftruncate(file1_fd.get(), -1), SyscallFailsWithErrno(EINVAL)); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({})); } TEST(Inotify, GetdentsGeneratesAccessEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); // This internally calls getdents(2). We also expect to see an open/close // event for the dirfd. ASSERT_NO_ERRNO_AND_VALUE(ListDir(root.path(), false)); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); // Linux only seems to generate access events on getdents() on some // calls. Allow the test to pass even if it isn't generated. gVisor will // always generate the IN_ACCESS event so the test will at least ensure gVisor // behaves reasonably. int i = 0; EXPECT_EQ(events[i].mask, IN_OPEN | IN_ISDIR); ++i; if (IsRunningOnGvisor()) { EXPECT_EQ(events[i].mask, IN_ACCESS | IN_ISDIR); ++i; } else { if (events[i].mask == (IN_ACCESS | IN_ISDIR)) { // Skip over the IN_ACCESS event on Linux, it only shows up some of the // time so we can't assert its existence. ++i; } } EXPECT_EQ(events[i].mask, IN_CLOSE_NOWRITE | IN_ISDIR); } TEST(Inotify, MknodGeneratesCreateEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const TempPath file1(root.path() + "/file1"); ASSERT_THAT(mknod(file1.path().c_str(), S_IFREG, 0), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_CREATE, wd, Basename(file1.path()))})); } TEST(Inotify, SymlinkGeneratesCreateEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const TempPath link1(NewTempAbsPathInDir(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); ASSERT_THAT(symlink(file1.path().c_str(), link1.path().c_str()), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_CREATE, root_wd, Basename(link1.path()))})); } TEST(Inotify, LinkGeneratesAttribAndCreateEvents) { // Inotify does not work properly with hard links in gofer and overlay fs. SKIP_IF(IsRunningOnGvisor() && !ASSERT_NO_ERRNO_AND_VALUE(IsTmpfs(GetAbsoluteTestTmpdir()))); const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const TempPath link1(root.path() + "/link1"); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); ASSERT_THAT(link(file1.path().c_str(), link1.path().c_str()), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_ATTRIB, file1_wd), Event(IN_CREATE, root_wd, Basename(link1.path()))})); } TEST(Inotify, UtimesGeneratesAttribEvent) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDWR)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const struct timeval times[2] = {{1, 0}, {2, 0}}; EXPECT_THAT(futimes(file1_fd.get(), times), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_ATTRIB, wd, Basename(file1.path()))})); } TEST(Inotify, HardlinksReuseSameWatch) { // Inotify does not work properly with hard links in gofer and overlay fs. SKIP_IF(IsRunningOnGvisor() && !ASSERT_NO_ERRNO_AND_VALUE(IsTmpfs(GetAbsoluteTestTmpdir()))); const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); TempPath file2(root.path() + "/file2"); ASSERT_THAT(link(file.path().c_str(), file2.path().c_str()), SyscallSucceeds()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int root_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int file_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file.path(), IN_ALL_EVENTS)); const int file2_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file2.path(), IN_ALL_EVENTS)); // The watch descriptors for watches on different links to the same file // should be identical. EXPECT_NE(root_wd, file_wd); EXPECT_EQ(file_wd, file2_wd); FileDescriptor file_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_WRONLY)); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, AreUnordered({Event(IN_OPEN, root_wd, Basename(file.path())), Event(IN_OPEN, file_wd)})); // For the next step, we want to ensure all fds to the file are closed. Do // that now and drain the resulting events. file_fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, AreUnordered({Event(IN_CLOSE_WRITE, root_wd, Basename(file.path())), Event(IN_CLOSE_WRITE, file_wd)})); // Try removing the link and let's see what events show up. Note that after // this, we still have a link to the file so the watch shouldn't be // automatically removed. const std::string file2_path = file2.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, AreUnordered({Event(IN_ATTRIB, file2_wd), Event(IN_DELETE, root_wd, Basename(file2_path))})); // Now remove the other link. Since this is the last link to the file, the // watch should be automatically removed. const std::string file_path = file.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, AreUnordered({Event(IN_ATTRIB, file_wd), Event(IN_DELETE_SELF, file_wd), Event(IN_IGNORED, file_wd), Event(IN_DELETE, root_wd, Basename(file_path))})); } // Calling mkdir within "parent/child" should generate an event for child, but // not parent. TEST(Inotify, MkdirGeneratesCreateEventWithDirFlag) { const TempPath parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath child = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), parent.path(), IN_ALL_EVENTS)); const int child_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), child.path(), IN_ALL_EVENTS)); const TempPath dir1(NewTempAbsPathInDir(child.path())); ASSERT_THAT(mkdir(dir1.path().c_str(), 0777), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT( events, Are({Event(IN_CREATE | IN_ISDIR, child_wd, Basename(dir1.path()))})); } TEST(Inotify, MultipleInotifyInstancesAndWatchesAllGetEvents) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_WRONLY)); constexpr int kNumFds = 30; std::vector<FileDescriptor> inotify_fds; for (int i = 0; i < kNumFds; ++i) { const DisableSave ds; // Too expensive. inotify_fds.emplace_back( ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK))); const FileDescriptor& fd = inotify_fds[inotify_fds.size() - 1]; // Back. ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); } const std::string data = "some content"; EXPECT_THAT(write(file1_fd.get(), data.c_str(), data.length()), SyscallSucceeds()); for (const FileDescriptor& fd : inotify_fds) { const DisableSave ds; // Too expensive. const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); if (events.size() >= 2) { EXPECT_EQ(events[0].mask, IN_MODIFY); EXPECT_EQ(events[0].wd, 1); EXPECT_EQ(events[0].name, Basename(file1.path())); EXPECT_EQ(events[1].mask, IN_MODIFY); EXPECT_EQ(events[1].wd, 2); EXPECT_EQ(events[1].name, ""); } } } TEST(Inotify, EventsGoUpAtMostOneLevel) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(root.path())); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir1.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), root.path(), IN_ALL_EVENTS)); const int dir1_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), dir1.path(), IN_ALL_EVENTS)); const std::string file1_path = file1.reset(); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_DELETE, dir1_wd, Basename(file1_path))})); } TEST(Inotify, DuplicateWatchReturnsSameWatchDescriptor) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd1 = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); const int wd2 = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); EXPECT_EQ(wd1, wd2); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_WRONLY)); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); // The watch shouldn't be duplicated, we only expect one event. ASSERT_THAT(events, Are({Event(IN_OPEN, wd1)})); } TEST(Inotify, UnmatchedEventsAreDiscarded) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ACCESS)); FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_WRONLY)); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); // We only asked for access events, the open event should be discarded. ASSERT_THAT(events, Are({})); // IN_IGNORED events are always generated, regardless of the mask. file1_fd.reset(); file1.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_IGNORED, wd)})); } TEST(Inotify, AddWatchWithInvalidEventMaskFails) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); EXPECT_THAT(inotify_add_watch(fd.get(), root.path().c_str(), 0), SyscallFailsWithErrno(EINVAL)); } TEST(Inotify, AddWatchOnInvalidPathFails) { const TempPath nonexistent(NewTempAbsPath()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); // Non-existent path. EXPECT_THAT( inotify_add_watch(fd.get(), nonexistent.path().c_str(), IN_CREATE), SyscallFailsWithErrno(ENOENT)); // Garbage path pointer. EXPECT_THAT(inotify_add_watch(fd.get(), nullptr, IN_CREATE), SyscallFailsWithErrno(EFAULT)); } TEST(Inotify, InOnlyDirFlagRespected) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); EXPECT_THAT( inotify_add_watch(fd.get(), root.path().c_str(), IN_ACCESS | IN_ONLYDIR), SyscallSucceeds()); EXPECT_THAT( inotify_add_watch(fd.get(), file1.path().c_str(), IN_ACCESS | IN_ONLYDIR), SyscallFailsWithErrno(ENOTDIR)); } TEST(Inotify, MaskAddMergesWithExistingEventMask) { const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(root.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_WRONLY)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_OPEN | IN_CLOSE_WRITE)); const std::string data = "some content"; EXPECT_THAT(write(file1_fd.get(), data.c_str(), data.length()), SyscallSucceeds()); // We shouldn't get any events, since IN_MODIFY wasn't in the event mask. std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({})); // Add IN_MODIFY to event mask. ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_MODIFY | IN_MASK_ADD)); EXPECT_THAT(write(file1_fd.get(), data.c_str(), data.length()), SyscallSucceeds()); // This time we should get the modify event. events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_MODIFY, wd)})); // Now close the fd. If the modify event was added to the event mask rather // than replacing the event mask we won't get the close event. file1_fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events, Are({Event(IN_CLOSE_WRITE, wd)})); } // Test that control events bits are not considered when checking event mask. TEST(Inotify, ControlEvents) { const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), dir.path(), IN_ACCESS)); // Check that events in the mask are dispatched and that control bits are // part of the event mask. std::vector<std::string> files = ASSERT_NO_ERRNO_AND_VALUE(ListDir(dir.path(), false)); ASSERT_EQ(files.size(), 2); const std::vector<Event> events1 = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events1, Are({Event(IN_ACCESS | IN_ISDIR, wd)})); // Check that events not in the mask are discarded. const FileDescriptor dir_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(dir.path(), O_RDONLY | O_DIRECTORY)); const std::vector<Event> events2 = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); ASSERT_THAT(events2, Are({})); } // Regression test to ensure epoll and directory access doesn't deadlock. TEST(Inotify, EpollNoDeadlock) { const DisableSave ds; // Too many syscalls. const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); // Create lots of directories and watch all of them. const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); std::vector<TempPath> children; for (size_t i = 0; i < 1000; ++i) { auto child = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(root.path())); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), child.path(), IN_ACCESS)); children.emplace_back(std::move(child)); } // Run epoll_wait constantly in a separate thread. std::atomic<bool> done(false); ScopedThread th([&fd, &done] { for (auto start = absl::Now(); absl::Now() - start < absl::Seconds(5);) { FileDescriptor epoll_fd = ASSERT_NO_ERRNO_AND_VALUE(NewEpollFD()); ASSERT_NO_ERRNO(RegisterEpollFD(epoll_fd.get(), fd.get(), EPOLLIN | EPOLLOUT | EPOLLET, 0)); struct epoll_event result[1]; EXPECT_THAT(RetryEINTR(epoll_wait)(epoll_fd.get(), result, 1, -1), SyscallSucceedsWithValue(1)); sched_yield(); } done = true; }); // While epoll thread is running, constantly access all directories to // generate inotify events. while (!done) { std::vector<std::string> files = ASSERT_NO_ERRNO_AND_VALUE(ListDir(root.path(), false)); ASSERT_EQ(files.size(), 1002); for (const auto& child : files) { if (child == "." || child == "..") { continue; } ASSERT_NO_ERRNO_AND_VALUE(ListDir(JoinPath(root.path(), child), false)); } sched_yield(); } } TEST(Inotify, Fallocate) { const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), file.path(), IN_ALL_EVENTS)); // Do an arbitrary modification with fallocate. ASSERT_THAT(RetryEINTR(fallocate)(fd.get(), 0, 0, 123), SyscallSucceeds()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_MODIFY, wd)})); } TEST(Inotify, Utimensat) { SKIP_IF(IsRunningWithVFS1()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), file.path(), IN_ALL_EVENTS)); // Just update the access time. struct timespec times[2] = {}; times[0].tv_nsec = UTIME_NOW; times[1].tv_nsec = UTIME_OMIT; ASSERT_THAT(RetryEINTR(utimensat)(AT_FDCWD, file.path().c_str(), times, 0), SyscallSucceeds()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_ACCESS, wd)})); // Just the modify time. times[0].tv_nsec = UTIME_OMIT; times[1].tv_nsec = UTIME_NOW; ASSERT_THAT(utimensat(AT_FDCWD, file.path().c_str(), times, 0), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_MODIFY, wd)})); // Both together. times[0].tv_nsec = UTIME_NOW; times[1].tv_nsec = UTIME_NOW; ASSERT_THAT(utimensat(AT_FDCWD, file.path().c_str(), times, 0), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_ATTRIB, wd)})); } TEST(Inotify, Sendfile) { SKIP_IF(IsRunningWithVFS1()); const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE( TempPath::CreateFileWith(root.path(), "x", 0644)); const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile()); const FileDescriptor in = ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY)); const FileDescriptor out = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY)); // Create separate inotify instances for the in and out fds. If both watches // were on the same instance, we would have discrepancies between Linux and // gVisor (order of events, duplicate events), which is not that important // since inotify is asynchronous anyway. const FileDescriptor in_inotify = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const FileDescriptor out_inotify = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int in_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(in_inotify.get(), in_file.path(), IN_ALL_EVENTS)); const int out_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(out_inotify.get(), out_file.path(), IN_ALL_EVENTS)); ASSERT_THAT(sendfile(out.get(), in.get(), /*offset=*/nullptr, 1), SyscallSucceeds()); // Expect a single access event and a single modify event. std::vector<Event> in_events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(in_inotify.get())); std::vector<Event> out_events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(out_inotify.get())); EXPECT_THAT(in_events, Are({Event(IN_ACCESS, in_wd)})); EXPECT_THAT(out_events, Are({Event(IN_MODIFY, out_wd)})); } TEST(Inotify, SpliceOnWatchTarget) { int pipefds[2]; ASSERT_THAT(pipe2(pipefds, O_NONBLOCK), SyscallSucceeds()); const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( dir.path(), "some content", TempPath::kDefaultFileMode)); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR)); const int dir_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), dir.path(), IN_ALL_EVENTS)); const int file_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), file.path(), IN_ALL_EVENTS)); EXPECT_THAT(splice(fd.get(), nullptr, pipefds[1], nullptr, 1, /*flags=*/0), SyscallSucceedsWithValue(1)); // Surprisingly, events may not be generated in Linux if we read from a file. // fs/splice.c:generic_file_splice_read, which is used most often, does not // generate events, whereas fs/splice.c:default_file_splice_read does. std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); if (IsRunningOnGvisor() && !IsRunningWithVFS1()) { ASSERT_THAT(events, Are({Event(IN_ACCESS, dir_wd, Basename(file.path())), Event(IN_ACCESS, file_wd)})); } EXPECT_THAT(splice(pipefds[0], nullptr, fd.get(), nullptr, 1, /*flags=*/0), SyscallSucceedsWithValue(1)); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); ASSERT_THAT(events, Are({ Event(IN_MODIFY, dir_wd, Basename(file.path())), Event(IN_MODIFY, file_wd), })); } TEST(Inotify, SpliceOnInotifyFD) { int pipefds[2]; ASSERT_THAT(pipe2(pipefds, O_NONBLOCK), SyscallSucceeds()); const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const TempPath file1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith( root.path(), "some content", TempPath::kDefaultFileMode)); const FileDescriptor file1_fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file1.path(), O_RDONLY)); const int watcher = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), file1.path(), IN_ALL_EVENTS)); char buf; EXPECT_THAT(read(file1_fd.get(), &buf, 1), SyscallSucceeds()); EXPECT_THAT(splice(fd.get(), nullptr, pipefds[1], nullptr, sizeof(struct inotify_event) + 1, SPLICE_F_NONBLOCK), SyscallSucceedsWithValue(sizeof(struct inotify_event))); const FileDescriptor read_fd(pipefds[0]); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(read_fd.get())); ASSERT_THAT(events, Are({Event(IN_ACCESS, watcher)})); } // Watches on a parent should not be triggered by actions on a hard link to one // of its children that has a different parent. TEST(Inotify, LinkOnOtherParent) { // Inotify does not work properly with hard links in gofer and overlay fs. SKIP_IF(IsRunningOnGvisor() && !ASSERT_NO_ERRNO_AND_VALUE(IsTmpfs(GetAbsoluteTestTmpdir()))); const TempPath dir1 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath dir2 = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir1.path())); std::string link_path = NewTempAbsPathInDir(dir2.path()); ASSERT_THAT(link(file.path().c_str(), link_path.c_str()), SyscallSucceeds()); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), dir1.path(), IN_ALL_EVENTS)); // Perform various actions on the link outside of dir1, which should trigger // no inotify events. FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(link_path.c_str(), O_RDWR)); int val = 0; ASSERT_THAT(write(fd.get(), &val, sizeof(val)), SyscallSucceeds()); ASSERT_THAT(read(fd.get(), &val, sizeof(val)), SyscallSucceeds()); ASSERT_THAT(ftruncate(fd.get(), 12345), SyscallSucceeds()); // Close before unlinking; some filesystems cannot restore an open fd on an // unlinked file. fd.reset(); ASSERT_THAT(unlink(link_path.c_str()), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({})); } TEST(Inotify, Xattr) { // TODO(gvisor.dev/issue/1636): Support extended attributes in runsc gofer. SKIP_IF(IsRunningOnGvisor()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile()); const std::string path = file.path(); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(path, O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), path, IN_ALL_EVENTS)); const char* cpath = path.c_str(); const char* name = "user.test"; int val = 123; ASSERT_THAT(setxattr(cpath, name, &val, sizeof(val), /*flags=*/0), SyscallSucceeds()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_ATTRIB, wd)})); ASSERT_THAT(getxattr(cpath, name, &val, sizeof(val)), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({})); char list[100]; ASSERT_THAT(listxattr(cpath, list, sizeof(list)), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({})); ASSERT_THAT(removexattr(cpath, name), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_ATTRIB, wd)})); ASSERT_THAT(fsetxattr(fd.get(), name, &val, sizeof(val), /*flags=*/0), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_ATTRIB, wd)})); ASSERT_THAT(fgetxattr(fd.get(), name, &val, sizeof(val)), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({})); ASSERT_THAT(flistxattr(fd.get(), list, sizeof(list)), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({})); ASSERT_THAT(fremovexattr(fd.get(), name), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({Event(IN_ATTRIB, wd)})); } TEST(Inotify, Exec) { SKIP_IF(IsRunningWithVFS1()); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(fd.get(), "/bin/true", IN_ALL_EVENTS)); // Perform exec. pid_t child = -1; int execve_errno = -1; auto kill = ASSERT_NO_ERRNO_AND_VALUE( ForkAndExec("/bin/true", {}, {}, nullptr, &child, &execve_errno)); ASSERT_EQ(0, execve_errno); int status; ASSERT_THAT(RetryEINTR(waitpid)(child, &status, 0), SyscallSucceeds()); EXPECT_EQ(0, status); // Process cleanup no longer needed. kill.Release(); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(fd.get())); EXPECT_THAT(events, Are({Event(IN_OPEN, wd), Event(IN_ACCESS, wd), Event(IN_CLOSE_NOWRITE, wd)})); } // Watches without IN_EXCL_UNLINK, should continue to emit events for file // descriptors after their corresponding files have been unlinked. // // We need to disable S/R because there are filesystems where we cannot re-open // fds to an unlinked file across S/R, e.g. gofer-backed filesytems. TEST(Inotify, IncludeUnlinkedFile_NoRandomSave) { const DisableSave ds; const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE( TempPath::CreateFileWith(dir.path(), "123", TempPath::kDefaultFileMode)); FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int dir_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), dir.path(), IN_ALL_EVENTS)); const int file_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), file.path(), IN_ALL_EVENTS)); ASSERT_THAT(unlink(file.path().c_str()), SyscallSucceeds()); int val = 0; ASSERT_THAT(read(fd.get(), &val, sizeof(val)), SyscallSucceeds()); ASSERT_THAT(write(fd.get(), &val, sizeof(val)), SyscallSucceeds()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, AnyOf(Are({ Event(IN_ATTRIB, file_wd), Event(IN_DELETE, dir_wd, Basename(file.path())), Event(IN_ACCESS, dir_wd, Basename(file.path())), Event(IN_ACCESS, file_wd), Event(IN_MODIFY, dir_wd, Basename(file.path())), Event(IN_MODIFY, file_wd), }), Are({ Event(IN_DELETE, dir_wd, Basename(file.path())), Event(IN_ATTRIB, file_wd), Event(IN_ACCESS, dir_wd, Basename(file.path())), Event(IN_ACCESS, file_wd), Event(IN_MODIFY, dir_wd, Basename(file.path())), Event(IN_MODIFY, file_wd), }))); fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_CLOSE_WRITE, dir_wd, Basename(file.path())), Event(IN_CLOSE_WRITE, file_wd), Event(IN_DELETE_SELF, file_wd), Event(IN_IGNORED, file_wd), })); } // Watches created with IN_EXCL_UNLINK will stop emitting events on fds for // children that have already been unlinked. // // We need to disable S/R because there are filesystems where we cannot re-open // fds to an unlinked file across S/R, e.g. gofer-backed filesytems. TEST(Inotify, ExcludeUnlink_NoRandomSave) { const DisableSave ds; // TODO(gvisor.dev/issue/1624): This test fails on VFS1. SKIP_IF(IsRunningWithVFS1()); const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path())); FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int dir_wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), dir.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); const int file_wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), file.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); // Unlink the child, which should cause further operations on the open file // descriptor to be ignored. ASSERT_THAT(unlink(file.path().c_str()), SyscallSucceeds()); int val = 0; ASSERT_THAT(write(fd.get(), &val, sizeof(val)), SyscallSucceeds()); ASSERT_THAT(read(fd.get(), &val, sizeof(val)), SyscallSucceeds()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, AreUnordered({ Event(IN_ATTRIB, file_wd), Event(IN_DELETE, dir_wd, Basename(file.path())), })); fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); ASSERT_THAT(events, Are({ Event(IN_DELETE_SELF, file_wd), Event(IN_IGNORED, file_wd), })); } // We need to disable S/R because there are filesystems where we cannot re-open // fds to an unlinked file across S/R, e.g. gofer-backed filesytems. TEST(Inotify, ExcludeUnlinkDirectory_NoRandomSave) { // TODO(gvisor.dev/issue/1624): This test fails on VFS1. Remove once VFS1 is // deleted. SKIP_IF(IsRunningWithVFS1()); const DisableSave ds; const TempPath parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDirIn(parent.path())); std::string dirPath = dir.path(); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(dirPath.c_str(), O_RDONLY | O_DIRECTORY)); const int parent_wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), parent.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); const int self_wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), dir.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); // Unlink the dir, and then close the open fd. ASSERT_THAT(rmdir(dirPath.c_str()), SyscallSucceeds()); dir.reset(); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); // No close event should appear. ASSERT_THAT(events, Are({Event(IN_DELETE | IN_ISDIR, parent_wd, Basename(dirPath))})); fd.reset(); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); ASSERT_THAT(events, Are({ Event(IN_DELETE_SELF, self_wd), Event(IN_IGNORED, self_wd), })); } // If "dir/child" and "dir/child2" are links to the same file, and "dir/child" // is unlinked, a watch on "dir" with IN_EXCL_UNLINK will exclude future events // for fds on "dir/child" but not "dir/child2". // // We need to disable S/R because there are filesystems where we cannot re-open // fds to an unlinked file across S/R, e.g. gofer-backed filesytems. TEST(Inotify, ExcludeUnlinkMultipleChildren_NoRandomSave) { // Inotify does not work properly with hard links in gofer and overlay fs. SKIP_IF(IsRunningOnGvisor() && !ASSERT_NO_ERRNO_AND_VALUE(IsTmpfs(GetAbsoluteTestTmpdir()))); // TODO(gvisor.dev/issue/1624): This test fails on VFS1. SKIP_IF(IsRunningWithVFS1()); const DisableSave ds; const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path())); std::string path1 = file.path(); std::string path2 = NewTempAbsPathInDir(dir.path()); ASSERT_THAT(link(path1.c_str(), path2.c_str()), SyscallSucceeds()); const FileDescriptor fd1 = ASSERT_NO_ERRNO_AND_VALUE(Open(path1.c_str(), O_RDWR)); const FileDescriptor fd2 = ASSERT_NO_ERRNO_AND_VALUE(Open(path2.c_str(), O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), dir.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); // After unlinking path1, only events on the fd for path2 should be generated. ASSERT_THAT(unlink(path1.c_str()), SyscallSucceeds()); ASSERT_THAT(write(fd1.get(), "x", 1), SyscallSucceeds()); ASSERT_THAT(write(fd2.get(), "x", 1), SyscallSucceeds()); const std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_DELETE, wd, Basename(path1)), Event(IN_MODIFY, wd, Basename(path2)), })); } // On native Linux, actions of data type FSNOTIFY_EVENT_INODE are not affected // by IN_EXCL_UNLINK (see // fs/notify/inotify/inotify_fsnotify.c:inotify_handle_event). Inode-level // events include changes to metadata and extended attributes. // // We need to disable S/R because there are filesystems where we cannot re-open // fds to an unlinked file across S/R, e.g. gofer-backed filesytems. TEST(Inotify, ExcludeUnlinkInodeEvents_NoRandomSave) { // TODO(gvisor.dev/issue/1624): Fails on VFS1. SKIP_IF(IsRunningWithVFS1()); // NOTE(gvisor.dev/issue/3654): In the gofer filesystem, we do not allow // setting attributes through an fd if the file at the open path has been // deleted. SKIP_IF(IsRunningOnGvisor() && !ASSERT_NO_ERRNO_AND_VALUE(IsTmpfs(GetAbsoluteTestTmpdir()))); const DisableSave ds; const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir.path())); const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path().c_str(), O_RDWR)); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int dir_wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), dir.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); const int file_wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch( inotify_fd.get(), file.path(), IN_ALL_EVENTS | IN_EXCL_UNLINK)); // Even after unlinking, inode-level operations will trigger events regardless // of IN_EXCL_UNLINK. ASSERT_THAT(unlink(file.path().c_str()), SyscallSucceeds()); // Perform various actions on fd. ASSERT_THAT(ftruncate(fd.get(), 12345), SyscallSucceeds()); std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, AnyOf(Are({ Event(IN_ATTRIB, file_wd), Event(IN_DELETE, dir_wd, Basename(file.path())), Event(IN_MODIFY, dir_wd, Basename(file.path())), Event(IN_MODIFY, file_wd), }), Are({ Event(IN_DELETE, dir_wd, Basename(file.path())), Event(IN_ATTRIB, file_wd), Event(IN_MODIFY, dir_wd, Basename(file.path())), Event(IN_MODIFY, file_wd), }))); const struct timeval times[2] = {{1, 0}, {2, 0}}; ASSERT_THAT(futimes(fd.get(), times), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_ATTRIB, dir_wd, Basename(file.path())), Event(IN_ATTRIB, file_wd), })); // S/R is disabled on this entire test due to behavior with unlink; it must // also be disabled after this point because of fchmod. ASSERT_THAT(fchmod(fd.get(), 0777), SyscallSucceeds()); events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_ATTRIB, dir_wd, Basename(file.path())), Event(IN_ATTRIB, file_wd), })); } TEST(Inotify, OneShot) { // TODO(gvisor.dev/issue/1624): IN_ONESHOT not supported in VFS1. SKIP_IF(IsRunningWithVFS1()); const TempPath file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile()); const FileDescriptor inotify_fd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); const int wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(inotify_fd.get(), file.path(), IN_MODIFY | IN_ONESHOT)); // Open an fd, write to it, and then close it. FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(file.path(), O_WRONLY)); ASSERT_THAT(write(fd.get(), "x", 1), SyscallSucceedsWithValue(1)); fd.reset(); // We should get a single event followed by IN_IGNORED indicating removal // of the one-shot watch. Prior activity (i.e. open) that is not in the mask // should not trigger removal, and activity after removal (i.e. close) should // not generate events. std::vector<Event> events = ASSERT_NO_ERRNO_AND_VALUE(DrainEvents(inotify_fd.get())); EXPECT_THAT(events, Are({ Event(IN_MODIFY, wd), Event(IN_IGNORED, wd), })); // The watch should already have been removed. EXPECT_THAT(inotify_rm_watch(inotify_fd.get(), wd), SyscallFailsWithErrno(EINVAL)); } // This test helps verify that the lock order of filesystem and inotify locks // is respected when inotify instances and watch targets are concurrently being // destroyed. TEST(InotifyTest, InotifyAndTargetDestructionDoNotDeadlock_NoRandomSave) { const DisableSave ds; // Too many syscalls. // A file descriptor protected by a mutex. This ensures that while a // descriptor is in use, it cannot be closed and reused for a different file // description. struct atomic_fd { int fd; absl::Mutex mu; }; // Set up initial inotify instances. constexpr int num_fds = 3; std::vector<atomic_fd> fds(num_fds); for (int i = 0; i < num_fds; i++) { int fd; ASSERT_THAT(fd = inotify_init1(IN_NONBLOCK), SyscallSucceeds()); fds[i].fd = fd; } // Set up initial watch targets. std::vector<std::string> paths; for (int i = 0; i < 3; i++) { paths.push_back(NewTempAbsPath()); ASSERT_THAT(mknod(paths[i].c_str(), S_IFREG | 0600, 0), SyscallSucceeds()); } constexpr absl::Duration runtime = absl::Seconds(4); // Constantly replace each inotify instance with a new one. auto replace_fds = [&] { for (auto start = absl::Now(); absl::Now() - start < runtime;) { for (auto& afd : fds) { int new_fd; ASSERT_THAT(new_fd = inotify_init1(IN_NONBLOCK), SyscallSucceeds()); absl::MutexLock l(&afd.mu); ASSERT_THAT(close(afd.fd), SyscallSucceeds()); afd.fd = new_fd; for (auto& p : paths) { // inotify_add_watch may fail if the file at p was deleted. ASSERT_THAT(inotify_add_watch(afd.fd, p.c_str(), IN_ALL_EVENTS), AnyOf(SyscallSucceeds(), SyscallFailsWithErrno(ENOENT))); } } sched_yield(); } }; std::list<ScopedThread> ts; for (int i = 0; i < 3; i++) { ts.emplace_back(replace_fds); } // Constantly replace each watch target with a new one. for (auto start = absl::Now(); absl::Now() - start < runtime;) { for (auto& p : paths) { ASSERT_THAT(unlink(p.c_str()), SyscallSucceeds()); ASSERT_THAT(mknod(p.c_str(), S_IFREG | 0600, 0), SyscallSucceeds()); } sched_yield(); } } // This test helps verify that the lock order of filesystem and inotify locks // is respected when adding/removing watches occurs concurrently with the // removal of their targets. TEST(InotifyTest, AddRemoveUnlinkDoNotDeadlock_NoRandomSave) { const DisableSave ds; // Too many syscalls. // Set up inotify instances. constexpr int num_fds = 3; std::vector<int> fds(num_fds); for (int i = 0; i < num_fds; i++) { ASSERT_THAT(fds[i] = inotify_init1(IN_NONBLOCK), SyscallSucceeds()); } // Set up initial watch targets. std::vector<std::string> paths; for (int i = 0; i < 3; i++) { paths.push_back(NewTempAbsPath()); ASSERT_THAT(mknod(paths[i].c_str(), S_IFREG | 0600, 0), SyscallSucceeds()); } constexpr absl::Duration runtime = absl::Seconds(1); // Constantly add/remove watches for each inotify instance/watch target pair. auto add_remove_watches = [&] { for (auto start = absl::Now(); absl::Now() - start < runtime;) { for (int fd : fds) { for (auto& p : paths) { // Do not assert on inotify_add_watch and inotify_rm_watch. They may // fail if the file at p was deleted. inotify_add_watch may also fail // if another thread beat us to adding a watch. const int wd = inotify_add_watch(fd, p.c_str(), IN_ALL_EVENTS); if (wd > 0) { inotify_rm_watch(fd, wd); } } } sched_yield(); } }; std::list<ScopedThread> ts; for (int i = 0; i < 15; i++) { ts.emplace_back(add_remove_watches); } // Constantly replace each watch target with a new one. for (auto start = absl::Now(); absl::Now() - start < runtime;) { for (auto& p : paths) { ASSERT_THAT(unlink(p.c_str()), SyscallSucceeds()); ASSERT_THAT(mknod(p.c_str(), S_IFREG | 0600, 0), SyscallSucceeds()); } sched_yield(); } } // This test helps verify that the lock order of filesystem and inotify locks // is respected when many inotify events and filesystem operations occur // simultaneously. TEST(InotifyTest, NotifyNoDeadlock_NoRandomSave) { const DisableSave ds; // Too many syscalls. const TempPath parent = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir()); const std::string dir = parent.path(); // mu protects file, which will change on rename. absl::Mutex mu; std::string file = NewTempAbsPathInDir(dir); ASSERT_THAT(mknod(file.c_str(), 0644 | S_IFREG, 0), SyscallSucceeds()); const absl::Duration runtime = absl::Milliseconds(300); // Add/remove watches on dir and file. ScopedThread add_remove_watches([&] { const FileDescriptor ifd = ASSERT_NO_ERRNO_AND_VALUE(InotifyInit1(IN_NONBLOCK)); int dir_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(ifd.get(), dir, IN_ALL_EVENTS)); int file_wd; { absl::ReaderMutexLock l(&mu); file_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(ifd.get(), file, IN_ALL_EVENTS)); } for (auto start = absl::Now(); absl::Now() - start < runtime;) { ASSERT_THAT(inotify_rm_watch(ifd.get(), file_wd), SyscallSucceeds()); ASSERT_THAT(inotify_rm_watch(ifd.get(), dir_wd), SyscallSucceeds()); dir_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(ifd.get(), dir, IN_ALL_EVENTS)); { absl::ReaderMutexLock l(&mu); file_wd = ASSERT_NO_ERRNO_AND_VALUE( InotifyAddWatch(ifd.get(), file, IN_ALL_EVENTS)); } sched_yield(); } }); // Modify attributes on dir and file. ScopedThread stats([&] { int fd, dir_fd; { absl::ReaderMutexLock l(&mu); ASSERT_THAT(fd = open(file.c_str(), O_RDONLY), SyscallSucceeds()); } ASSERT_THAT(dir_fd = open(dir.c_str(), O_RDONLY | O_DIRECTORY), SyscallSucceeds()); const struct timeval times[2] = {{1, 0}, {2, 0}}; for (auto start = absl::Now(); absl::Now() - start < runtime;) { { absl::ReaderMutexLock l(&mu); EXPECT_THAT(utimes(file.c_str(), times), SyscallSucceeds()); } EXPECT_THAT(futimes(fd, times), SyscallSucceeds()); EXPECT_THAT(utimes(dir.c_str(), times), SyscallSucceeds()); EXPECT_THAT(futimes(dir_fd, times), SyscallSucceeds()); sched_yield(); } }); // Modify extended attributes on dir and file. ScopedThread xattrs([&] { // TODO(gvisor.dev/issue/1636): Support extended attributes in runsc gofer. if (!IsRunningOnGvisor()) { int fd; { absl::ReaderMutexLock l(&mu); ASSERT_THAT(fd = open(file.c_str(), O_RDONLY), SyscallSucceeds()); } const char* name = "user.test"; int val = 123; for (auto start = absl::Now(); absl::Now() - start < runtime;) { { absl::ReaderMutexLock l(&mu); ASSERT_THAT( setxattr(file.c_str(), name, &val, sizeof(val), /*flags=*/0), SyscallSucceeds()); ASSERT_THAT(removexattr(file.c_str(), name), SyscallSucceeds()); } ASSERT_THAT(fsetxattr(fd, name, &val, sizeof(val), /*flags=*/0), SyscallSucceeds()); ASSERT_THAT(fremovexattr(fd, name), SyscallSucceeds()); sched_yield(); } } }); // Read and write file's contents. Read and write dir's entries. ScopedThread read_write([&] { int fd; { absl::ReaderMutexLock l(&mu); ASSERT_THAT(fd = open(file.c_str(), O_RDWR), SyscallSucceeds()); } for (auto start = absl::Now(); absl::Now() - start < runtime;) { int val = 123; ASSERT_THAT(write(fd, &val, sizeof(val)), SyscallSucceeds()); ASSERT_THAT(read(fd, &val, sizeof(val)), SyscallSucceeds()); TempPath new_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileIn(dir)); ASSERT_NO_ERRNO(ListDir(dir, false)); new_file.reset(); sched_yield(); } }); // Rename file. for (auto start = absl::Now(); absl::Now() - start < runtime;) { const std::string new_path = NewTempAbsPathInDir(dir); { absl::WriterMutexLock l(&mu); ASSERT_THAT(rename(file.c_str(), new_path.c_str()), SyscallSucceeds()); file = new_path; } sched_yield(); } } } // namespace } // namespace testing } // namespace gvisor