361 lines
12 KiB
C++
361 lines
12 KiB
C++
|
//===- 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/Error.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() {
|
||
|
|
#ifndef NDEBUG
|
||
|
|
ssize_t Result =
|
||
|
|
#endif
|
||
|
|
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.
|
||
|
|
|
||
|
|
struct Buffer {
|
||
|
|
alignas(struct inotify_event) char buffer[EventBufferLength];
|
||
|
|
};
|
||
|
|
auto ManagedBuffer = std::make_unique<Buffer>();
|
||
|
|
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 (int i = 0; i < EpollWaitResult; ++i) {
|
||
|
|
if (EpollEventBuffer[i].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
|
||
|
|
|
||
|
|
llvm::Expected<std::unique_ptr<DirectoryWatcher>> clang::DirectoryWatcher::create(
|
||
|
|
StringRef Path,
|
||
|
|
std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver,
|
||
|
|
bool WaitForInitialSync) {
|
||
|
|
if (Path.empty())
|
||
|
|
llvm::report_fatal_error(
|
||
|
|
"DirectoryWatcher::create can not accept an empty Path.");
|
||
|
|
|
||
|
|
const int InotifyFD = inotify_init1(IN_CLOEXEC);
|
||
|
|
if (InotifyFD == -1)
|
||
|
|
return llvm::make_error<llvm::StringError>(
|
||
|
|
std::string("inotify_init1() error: ") + strerror(errno),
|
||
|
|
llvm::inconvertibleErrorCode());
|
||
|
|
|
||
|
|
const int InotifyWD = inotify_add_watch(
|
||
|
|
InotifyFD, Path.str().c_str(),
|
||
|
|
IN_CREATE | IN_DELETE | IN_DELETE_SELF | IN_MODIFY |
|
||
|
|
IN_MOVED_FROM | IN_MOVE_SELF | IN_MOVED_TO | IN_ONLYDIR | IN_IGNORED
|
||
|
|
#ifdef IN_EXCL_UNLINK
|
||
|
|
| IN_EXCL_UNLINK
|
||
|
|
#endif
|
||
|
|
);
|
||
|
|
if (InotifyWD == -1)
|
||
|
|
return llvm::make_error<llvm::StringError>(
|
||
|
|
std::string("inotify_add_watch() error: ") + strerror(errno),
|
||
|
|
llvm::inconvertibleErrorCode());
|
||
|
|
|
||
|
|
auto InotifyPollingStopper = SemaphorePipe::create();
|
||
|
|
|
||
|
|
if (!InotifyPollingStopper)
|
||
|
|
return llvm::make_error<llvm::StringError>(
|
||
|
|
std::string("SemaphorePipe::create() error: ") + strerror(errno),
|
||
|
|
llvm::inconvertibleErrorCode());
|
||
|
|
|
||
|
|
return std::make_unique<DirectoryWatcherLinux>(
|
||
|
|
Path, Receiver, WaitForInitialSync, InotifyFD, InotifyWD,
|
||
|
|
std::move(*InotifyPollingStopper));
|
||
|
|
}
|