compnerd created this revision.
compnerd added a reviewer: amccarth.
Herald added a project: clang.
compnerd requested review of this revision.
This implements the directory watcher on Windows. It does the most
naive thing for simplicity. ReadDirectoryChangesW is used to monitor
the changes. However, in order to support interruption, we must use
overlapped IO, which allows us to use the blocking, synchronous
mechanism. We create a thread to post the notification to the consumer
to allow the monitoring to continue. The two threads communicate via a
locked queue.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D88666
Files:
clang/lib/DirectoryWatcher/windows/DirectoryWatcher-windows.cpp
Index: clang/lib/DirectoryWatcher/windows/DirectoryWatcher-windows.cpp
===================================================================
--- clang/lib/DirectoryWatcher/windows/DirectoryWatcher-windows.cpp
+++ clang/lib/DirectoryWatcher/windows/DirectoryWatcher-windows.cpp
@@ -6,17 +6,11 @@
//
//===----------------------------------------------------------------------===//
-// TODO: This is not yet an implementation, but it will make it so Windows
-// builds don't fail.
-
#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/ConvertUTF.h"
#include "llvm/Support/Path.h"
#include <atomic>
#include <condition_variable>
@@ -24,27 +18,232 @@
#include <queue>
#include <string>
#include <thread>
-#include <vector>
+
+#include <Windows.h>
namespace {
+using DirectoryWatcherCallback =
+ std::function<void(llvm::ArrayRef<clang::DirectoryWatcher::Event>, bool)>;
+
using namespace llvm;
using namespace clang;
class DirectoryWatcherWindows : public clang::DirectoryWatcher {
+ OVERLAPPED ovlIO;
+
+ alignas(DWORD)
+ CHAR Buffer[4 * (sizeof(FILE_NOTIFY_INFORMATION) + MAX_PATH * sizeof(WCHAR))];
+
+ std::thread WatcherThread;
+ std::thread HandlerThread;
+ std::function<void(ArrayRef<DirectoryWatcher::Event>, bool)> Callback;
+ SmallString<MAX_PATH> Path;
+
+ class EventQueue {
+ std::mutex M;
+ std::queue<DirectoryWatcher::Event> Q;
+ std::condition_variable CV;
+
+ public:
+ void emplace(DirectoryWatcher::Event::EventKind Kind, StringRef Path) {
+ {
+ std::unique_lock<std::mutex> L(M);
+ Q.emplace(Kind, Path);
+ }
+ CV.notify_one();
+ }
+
+ DirectoryWatcher::Event pop_front() {
+ std::unique_lock<std::mutex> L(M);
+ while (true) {
+ if (!Q.empty()) {
+ DirectoryWatcher::Event E = Q.front();
+ Q.pop();
+ return E;
+ }
+ CV.wait(L, [this]() { return !Q.empty(); });
+ }
+ }
+ } Q;
+
public:
- ~DirectoryWatcherWindows() override { }
- void InitialScan() { }
- void EventReceivingLoop() { }
- void StopWork() { }
+ DirectoryWatcherWindows(HANDLE hDirectory, bool WaitForInitialSync,
+ DirectoryWatcherCallback Receiver);
+
+ ~DirectoryWatcherWindows() override;
+
+ void InitialScan();
};
+
+DirectoryWatcherWindows::DirectoryWatcherWindows(
+ HANDLE hDirectory, bool WaitForInitialSync,
+ DirectoryWatcherCallback Receiver)
+ : Callback(Receiver) {
+ // Pre-compute the real location as we will be handing over the directory
+ // handle to the watcher and performing synchronous operations.
+ {
+ DWORD dwLength = GetFinalPathNameByHandleW(hDirectory, NULL, 0, 0);
+ std::unique_ptr<WCHAR[]> buffer{new WCHAR[dwLength + 1]};
+ (void)GetFinalPathNameByHandleW(hDirectory, buffer.get(), dwLength + 1, 0);
+ sys::windows::UTF16ToUTF8(buffer.get(), dwLength + 1, Path);
+ }
+
+ memset(&ovlIO, 0, sizeof(ovlIO));
+ ovlIO.hEvent =
+ CreateEvent(NULL, /*bManualReset=*/TRUE, /*bInitialState=*/FALSE, NULL);
+ assert(ovlIO.hEvent);
+
+ WatcherThread = std::thread([this, hDirectory]() {
+ while (true) {
+ // We do not guarantee subdirectories, but macOS already provides
+ // subdirectories, might as well as ...
+ const BOOL bWatchSubtree = TRUE;
+ const DWORD dwNotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME
+ | FILE_NOTIFY_CHANGE_DIR_NAME
+ | FILE_NOTIFY_CHANGE_SIZE
+ | FILE_NOTIFY_CHANGE_LAST_ACCESS
+ | FILE_NOTIFY_CHANGE_LAST_WRITE
+ | FILE_NOTIFY_CHANGE_CREATION;
+
+ DWORD BytesTransferred;
+ if (!ReadDirectoryChangesW(hDirectory, Buffer, sizeof(Buffer),
+ bWatchSubtree, dwNotifyFilter,
+ &BytesTransferred, &ovlIO, NULL)) {
+ Q.emplace(DirectoryWatcher::Event::EventKind::WatcherGotInvalidated,
+ "");
+ break;
+ }
+
+ if (!GetOverlappedResult(hDirectory, &ovlIO, &BytesTransferred, TRUE)) {
+ Q.emplace(DirectoryWatcher::Event::EventKind::WatcherGotInvalidated,
+ "");
+ break;
+ }
+
+ // There was a buffer underrun on the kernel side. We may have lost
+ // events, please re-synchronize.
+ if (BytesTransferred == 0) {
+ Q.emplace(DirectoryWatcher::Event::EventKind::WatcherGotInvalidated,
+ "");
+ break;
+ }
+
+ for (FILE_NOTIFY_INFORMATION *pFNI = (FILE_NOTIFY_INFORMATION *)Buffer;
+ pFNI;
+ pFNI = pFNI->NextEntryOffset
+ ? (FILE_NOTIFY_INFORMATION *)((CHAR *)pFNI + pFNI->NextEntryOffset)
+ : NULL) {
+
+ DirectoryWatcher::Event::EventKind Kind =
+ DirectoryWatcher::Event::EventKind::WatcherGotInvalidated;
+ switch (pFNI->Action) {
+ case FILE_ACTION_MODIFIED:
+ Kind = DirectoryWatcher::Event::EventKind::Modified;
+ break;
+ case FILE_ACTION_ADDED:
+ Kind = DirectoryWatcher::Event::EventKind::Modified;
+ break;
+ case FILE_ACTION_REMOVED:
+ Kind = DirectoryWatcher::Event::EventKind::Removed;
+ break;
+ case FILE_ACTION_RENAMED_OLD_NAME:
+ Kind = DirectoryWatcher::Event::EventKind::Removed;
+ break;
+ case FILE_ACTION_RENAMED_NEW_NAME:
+ Kind = DirectoryWatcher::Event::EventKind::Modified;
+ break;
+ }
+
+ SmallString<MAX_PATH> filename;
+ sys::windows::UTF16ToUTF8(pFNI->FileName, pFNI->FileNameLength / 2,
+ filename);
+ Q.emplace(Kind, filename);
+ }
+ }
+
+ (void)CloseHandle(hDirectory);
+ });
+
+ if (WaitForInitialSync)
+ InitialScan();
+ HandlerThread = std::thread([this, WaitForInitialSync]() {
+ // If we did not wait for the initial sync, then we should perform the
+ // scan when we enter the thread.
+ if (!WaitForInitialSync)
+ this->InitialScan();
+
+ while (true) {
+ DirectoryWatcher::Event E = Q.pop_front();
+ Callback(E, /*IsInitial=*/false);
+ if (E.Kind == DirectoryWatcher::Event::EventKind::WatcherGotInvalidated)
+ break;
+ }
+ });
+}
+
+DirectoryWatcherWindows::~DirectoryWatcherWindows() {
+ // Signal the Watcher to exit.
+ SetEvent(ovlIO.hEvent);
+ HandlerThread.join();
+ WatcherThread.join();
+}
+
+void DirectoryWatcherWindows::InitialScan() {
+ Callback(getAsFileEvents(scanDirectory(Path.data())), /*IsInitial=*/true);
+}
+
+auto error(DWORD dwError) {
+ const DWORD dwFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER
+ | FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_IGNORE_INSERTS;
+
+ LPSTR buffer;
+ if (!FormatMessageA(dwFlags, NULL, dwError,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&buffer,
+ 0, NULL)) {
+ return make_error<llvm::StringError>("error " + utostr(dwError),
+ inconvertibleErrorCode());
+ }
+ std::string message{buffer};
+ LocalFree(buffer);
+ return make_error<llvm::StringError>(message, inconvertibleErrorCode());
+}
+
} // namespace
llvm::Expected<std::unique_ptr<DirectoryWatcher>>
-clang::DirectoryWatcher::create(
- StringRef Path,
- std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver,
- bool WaitForInitialSync) {
- return llvm::Expected<std::unique_ptr<DirectoryWatcher>>(
- llvm::errorCodeToError(std::make_error_code(std::errc::not_supported)));
+clang::DirectoryWatcher::create(StringRef Path,
+ DirectoryWatcherCallback Receiver,
+ bool WaitForInitialSync) {
+ if (Path.empty())
+ llvm::report_fatal_error(
+ "DirectoryWatcher::create can not accept an empty Path.");
+
+ // FIXME(compnerd) should we assert that the path is a directory?
+ SmallVector<wchar_t, MAX_PATH> WidePath;
+ if (sys::windows::UTF8ToUTF16(Path, WidePath))
+ return llvm::make_error<llvm::StringError>("unable to convert path to UTF-16",
+ llvm::inconvertibleErrorCode());
+
+ const DWORD dwDesiredAccess = FILE_LIST_DIRECTORY;
+ const DWORD dwShareMode =
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+ const DWORD dwCreationDisposition = OPEN_EXISTING;
+ const DWORD dwFlagsAndAttributes =
+ FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
+
+ HANDLE hDirectory =
+ CreateFileW(WidePath.data(), dwDesiredAccess, dwShareMode,
+ /*lpSecurityAttributes=*/NULL,
+ dwCreationDisposition, dwFlagsAndAttributes, NULL);
+ if (hDirectory == INVALID_HANDLE_VALUE)
+ return error(GetLastError());
+
+ // NOTE: We use the watcher instance as a RAII object to discard the handles
+ // for the directory and the IOCP in case of an error. Hence, this is early
+ // allocated, with the state being written directly to the watcher.
+ return std::make_unique<DirectoryWatcherWindows>(hDirectory,
+ WaitForInitialSync,
+ Receiver);
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
