diff options
Diffstat (limited to 'clang/lib/DirectoryWatcher/linux')
| -rw-r--r-- | clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp | 345 |
1 files changed, 345 insertions, 0 deletions
diff --git a/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp b/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp new file mode 100644 index 00000000000..986ebc5d95f --- /dev/null +++ b/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp @@ -0,0 +1,345 @@ +//===- DirectoryWatcher-linux.cpp - Linux-platform directory watching -----===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "DirectoryScanner.h" +#include "clang/DirectoryWatcher/DirectoryWatcher.h" + +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/ScopeExit.h" +#include "llvm/Support/AlignOf.h" +#include "llvm/Support/Errno.h" +#include "llvm/Support/Mutex.h" +#include "llvm/Support/Path.h" +#include <atomic> +#include <condition_variable> +#include <mutex> +#include <queue> +#include <string> +#include <thread> +#include <vector> + +#include <fcntl.h> +#include <sys/epoll.h> +#include <sys/inotify.h> +#include <unistd.h> + +namespace { + +using namespace llvm; +using namespace clang; + +/// Pipe for inter-thread synchronization - for epoll-ing on multiple +/// conditions. It is meant for uni-directional 1:1 signalling - specifically: +/// no multiple consumers, no data passing. Thread waiting for signal should +/// poll the FDRead. Signalling thread should call signal() which writes single +/// character to FDRead. +struct SemaphorePipe { + // Expects two file-descriptors opened as a pipe in the canonical POSIX + // order: pipefd[0] refers to the read end of the pipe. pipefd[1] refers to + // the write end of the pipe. + SemaphorePipe(int pipefd[2]) + : FDRead(pipefd[0]), FDWrite(pipefd[1]), OwnsFDs(true) {} + SemaphorePipe(const SemaphorePipe &) = delete; + void operator=(const SemaphorePipe &) = delete; + SemaphorePipe(SemaphorePipe &&other) + : FDRead(other.FDRead), FDWrite(other.FDWrite), + OwnsFDs(other.OwnsFDs) // Someone could have moved from the other + // instance before. + { + other.OwnsFDs = false; + }; + + void signal() { + ssize_t Result = llvm::sys::RetryAfterSignal(-1, write, FDWrite, "A", 1); + assert(Result != -1); + } + ~SemaphorePipe() { + if (OwnsFDs) { + close(FDWrite); + close(FDRead); + } + } + const int FDRead; + const int FDWrite; + bool OwnsFDs; + + static llvm::Optional<SemaphorePipe> create() { + int InotifyPollingStopperFDs[2]; + if (pipe2(InotifyPollingStopperFDs, O_CLOEXEC) == -1) + return llvm::None; + return SemaphorePipe(InotifyPollingStopperFDs); + } +}; + +/// Mutex-protected queue of Events. +class EventQueue { + std::mutex Mtx; + std::condition_variable NonEmpty; + std::queue<DirectoryWatcher::Event> Events; + +public: + void push_back(const DirectoryWatcher::Event::EventKind K, + StringRef Filename) { + { + std::unique_lock<std::mutex> L(Mtx); + Events.emplace(K, Filename); + } + NonEmpty.notify_one(); + } + + // Blocks on caller thread and uses codition_variable to wait until there's an + // event to return. + DirectoryWatcher::Event pop_front_blocking() { + std::unique_lock<std::mutex> L(Mtx); + while (true) { + // Since we might have missed all the prior notifications on NonEmpty we + // have to check the queue first (under lock). + if (!Events.empty()) { + DirectoryWatcher::Event Front = Events.front(); + Events.pop(); + return Front; + } + NonEmpty.wait(L, [this]() { return !Events.empty(); }); + } + } +}; + +class DirectoryWatcherLinux : public clang::DirectoryWatcher { +public: + DirectoryWatcherLinux( + llvm::StringRef WatchedDirPath, + std::function<void(llvm::ArrayRef<Event>, bool)> Receiver, + bool WaitForInitialSync, int InotifyFD, int InotifyWD, + SemaphorePipe &&InotifyPollingStopSignal); + + ~DirectoryWatcherLinux() override { + StopWork(); + InotifyPollingThread.join(); + EventsReceivingThread.join(); + inotify_rm_watch(InotifyFD, InotifyWD); + llvm::sys::RetryAfterSignal(-1, close, InotifyFD); + } + +private: + const std::string WatchedDirPath; + // inotify file descriptor + int InotifyFD = -1; + // inotify watch descriptor + int InotifyWD = -1; + + EventQueue Queue; + + // Make sure lifetime of Receiver fully contains lifetime of + // EventsReceivingThread. + std::function<void(llvm::ArrayRef<Event>, bool)> Receiver; + + // Consumes inotify events and pushes directory watcher events to the Queue. + void InotifyPollingLoop(); + std::thread InotifyPollingThread; + // Using pipe so we can epoll two file descriptors at once - inotify and + // stopping condition. + SemaphorePipe InotifyPollingStopSignal; + + // Does the initial scan of the directory - directly calling Receiver, + // bypassing the Queue. Both InitialScan and EventReceivingLoop use Receiver + // which isn't necessarily thread-safe. + void InitialScan(); + + // Processing events from the Queue. + // In case client doesn't want to do the initial scan synchronously + // (WaitForInitialSync=false in ctor) we do the initial scan at the beginning + // of this thread. + std::thread EventsReceivingThread; + // Push event of WatcherGotInvalidated kind to the Queue to stop the loop. + // Both InitialScan and EventReceivingLoop use Receiver which isn't + // necessarily thread-safe. + void EventReceivingLoop(); + + // Stops all the async work. Reentrant. + void StopWork() { + Queue.push_back(DirectoryWatcher::Event::EventKind::WatcherGotInvalidated, + ""); + InotifyPollingStopSignal.signal(); + } +}; + +void DirectoryWatcherLinux::InotifyPollingLoop() { + // We want to be able to read ~30 events at once even in the worst case + // (obscenely long filenames). + constexpr size_t EventBufferLength = + 30 * (sizeof(struct inotify_event) + NAME_MAX + 1); + // http://man7.org/linux/man-pages/man7/inotify.7.html + // Some systems cannot read integer variables if they are not + // properly aligned. On other systems, incorrect alignment may + // decrease performance. Hence, the buffer used for reading from + // the inotify file descriptor should have the same alignment as + // struct inotify_event. + + auto ManagedBuffer = + llvm::make_unique<llvm::AlignedCharArray<alignof(struct inotify_event), + EventBufferLength>>(); + char *const Buf = ManagedBuffer->buffer; + + const int EpollFD = epoll_create1(EPOLL_CLOEXEC); + if (EpollFD == -1) { + StopWork(); + return; + } + auto EpollFDGuard = llvm::make_scope_exit([EpollFD]() { close(EpollFD); }); + + struct epoll_event EventSpec; + EventSpec.events = EPOLLIN; + EventSpec.data.fd = InotifyFD; + if (epoll_ctl(EpollFD, EPOLL_CTL_ADD, InotifyFD, &EventSpec) == -1) { + StopWork(); + return; + } + + EventSpec.data.fd = InotifyPollingStopSignal.FDRead; + if (epoll_ctl(EpollFD, EPOLL_CTL_ADD, InotifyPollingStopSignal.FDRead, + &EventSpec) == -1) { + StopWork(); + return; + } + + std::array<struct epoll_event, 2> EpollEventBuffer; + + while (true) { + const int EpollWaitResult = llvm::sys::RetryAfterSignal( + -1, epoll_wait, EpollFD, EpollEventBuffer.data(), + EpollEventBuffer.size(), /*timeout=*/-1 /*== infinity*/); + if (EpollWaitResult == -1) { + StopWork(); + return; + } + + // Multiple epoll_events can be received for a single file descriptor per + // epoll_wait call. + for (const auto &EpollEvent : EpollEventBuffer) { + if (EpollEvent.data.fd == InotifyPollingStopSignal.FDRead) { + StopWork(); + return; + } + } + + // epoll_wait() always return either error or >0 events. Since there was no + // event for stopping, it must be an inotify event ready for reading. + ssize_t NumRead = llvm::sys::RetryAfterSignal(-1, read, InotifyFD, Buf, + EventBufferLength); + for (char *P = Buf; P < Buf + NumRead;) { + if (P + sizeof(struct inotify_event) > Buf + NumRead) { + StopWork(); + llvm_unreachable("an incomplete inotify_event was read"); + return; + } + + struct inotify_event *Event = reinterpret_cast<struct inotify_event *>(P); + P += sizeof(struct inotify_event) + Event->len; + + if (Event->mask & (IN_CREATE | IN_MODIFY | IN_MOVED_TO | IN_DELETE) && + Event->len <= 0) { + StopWork(); + llvm_unreachable("expected a filename from inotify"); + return; + } + + if (Event->mask & (IN_CREATE | IN_MOVED_TO | IN_MODIFY)) { + Queue.push_back(DirectoryWatcher::Event::EventKind::Modified, + Event->name); + } else if (Event->mask & (IN_DELETE | IN_MOVED_FROM)) { + Queue.push_back(DirectoryWatcher::Event::EventKind::Removed, + Event->name); + } else if (Event->mask & (IN_DELETE_SELF | IN_MOVE_SELF)) { + Queue.push_back(DirectoryWatcher::Event::EventKind::WatchedDirRemoved, + ""); + StopWork(); + return; + } else if (Event->mask & IN_IGNORED) { + StopWork(); + return; + } else { + StopWork(); + llvm_unreachable("Unknown event type."); + return; + } + } + } +} + +void DirectoryWatcherLinux::InitialScan() { + this->Receiver(getAsFileEvents(scanDirectory(WatchedDirPath)), + /*IsInitial=*/true); +} + +void DirectoryWatcherLinux::EventReceivingLoop() { + while (true) { + DirectoryWatcher::Event Event = this->Queue.pop_front_blocking(); + this->Receiver(Event, false); + if (Event.Kind == + DirectoryWatcher::Event::EventKind::WatcherGotInvalidated) { + StopWork(); + return; + } + } +} + +DirectoryWatcherLinux::DirectoryWatcherLinux( + StringRef WatchedDirPath, + std::function<void(llvm::ArrayRef<Event>, bool)> Receiver, + bool WaitForInitialSync, int InotifyFD, int InotifyWD, + SemaphorePipe &&InotifyPollingStopSignal) + : WatchedDirPath(WatchedDirPath), InotifyFD(InotifyFD), + InotifyWD(InotifyWD), Receiver(Receiver), + InotifyPollingStopSignal(std::move(InotifyPollingStopSignal)) { + + InotifyPollingThread = std::thread([this]() { InotifyPollingLoop(); }); + // We have no guarantees about thread safety of the Receiver which is being + // used in both InitialScan and EventReceivingLoop. We shouldn't run these + // only synchronously. + if (WaitForInitialSync) { + InitialScan(); + EventsReceivingThread = std::thread([this]() { EventReceivingLoop(); }); + } else { + EventsReceivingThread = std::thread([this]() { + // FIXME: We might want to terminate an async initial scan early in case + // of a failure in EventsReceivingThread. + InitialScan(); + EventReceivingLoop(); + }); + } +} + +} // namespace + +std::unique_ptr<DirectoryWatcher> clang::DirectoryWatcher::create( + StringRef Path, + std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver, + bool WaitForInitialSync) { + if (Path.empty()) + return nullptr; + + const int InotifyFD = inotify_init1(IN_CLOEXEC); + if (InotifyFD == -1) + return nullptr; + + const int InotifyWD = inotify_add_watch( + InotifyFD, Path.str().c_str(), + IN_CREATE | IN_DELETE | IN_DELETE_SELF | IN_EXCL_UNLINK | IN_MODIFY | + IN_MOVED_FROM | IN_MOVE_SELF | IN_MOVED_TO | IN_ONLYDIR | IN_IGNORED); + if (InotifyWD == -1) + return nullptr; + + auto InotifyPollingStopper = SemaphorePipe::create(); + + if (!InotifyPollingStopper) + return nullptr; + + return llvm::make_unique<DirectoryWatcherLinux>( + Path, Receiver, WaitForInitialSync, InotifyFD, InotifyWD, + std::move(*InotifyPollingStopper)); +}
\ No newline at end of file |
