clang/lib/DirectoryWatcher/windows/DirectoryWatcher-windows.cpp

//===- DirectoryWatcher-windows.cpp - Windows-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/Support/ConvertUTF.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include <condition_variable>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
#include <vector>

namespace {

using DirectoryWatcherCallback =
    std::function<void(llvm::ArrayRef<clang::DirectoryWatcher::Event>, bool)>;

using namespace llvm;
using namespace clang;

class DirectoryWatcherWindows : public clang::DirectoryWatcher {
  OVERLAPPED Overlapped;

  std::vector<DWORD> Notifications;

  std::thread WatcherThread;
  std::thread HandlerThread;
  std::function<void(ArrayRef<DirectoryWatcher::Event>, bool)> Callback;
  SmallString<MAX_PATH> Path;
  HANDLE Terminate;

  std::mutex Mutex;
  bool WatcherActive = false;
  std::condition_variable Ready;

  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(HANDLE DirectoryHandle, bool WaitForInitialSync,
                          DirectoryWatcherCallback Receiver);

  ~DirectoryWatcherWindows() override;

  void InitialScan();
  void WatcherThreadProc(HANDLE DirectoryHandle);
  void NotifierThreadProc(bool WaitForInitialSync);
};

DirectoryWatcherWindows::DirectoryWatcherWindows(
    HANDLE DirectoryHandle, bool WaitForInitialSync,
    DirectoryWatcherCallback Receiver)
    : Callback(Receiver), Terminate(INVALID_HANDLE_VALUE) {
  // Pre-compute the real location as we will be handing over the directory
  // handle to the watcher and performing synchronous operations.
  {
    DWORD Size = GetFinalPathNameByHandleW(DirectoryHandle, NULL, 0, 0);
    std::unique_ptr<WCHAR[]> Buffer{new WCHAR[Size + 1]};
    Size = GetFinalPathNameByHandleW(DirectoryHandle, Buffer.get(), Size, 0);
    Buffer[Size] = L'\0';
    WCHAR *Data = Buffer.get();
    if (Size >= 4 && ::memcmp(Data, L"\\\\?\\", 8) == 0) {
      Data += 4;
      Size -= 4;
    }
    llvm::sys::windows::UTF16ToUTF8(Data, Size, Path);
  }

  size_t EntrySize = sizeof(FILE_NOTIFY_INFORMATION) + MAX_PATH * sizeof(WCHAR);
  Notifications.resize((4 * EntrySize) / sizeof(DWORD));

  memset(&Overlapped, 0, sizeof(Overlapped));
  Overlapped.hEvent =
      CreateEventW(NULL, /*bManualReset=*/FALSE, /*bInitialState=*/FALSE, NULL);
  assert(Overlapped.hEvent && "unable to create event");

  Terminate =
      CreateEventW(NULL, /*bManualReset=*/TRUE, /*bInitialState=*/FALSE, NULL);

  WatcherThread = std::thread([this, DirectoryHandle]() {
    this->WatcherThreadProc(DirectoryHandle);
  });

  if (WaitForInitialSync)
    InitialScan();

  HandlerThread = std::thread([this, WaitForInitialSync]() {
    this->NotifierThreadProc(WaitForInitialSync);
  });
}

DirectoryWatcherWindows::~DirectoryWatcherWindows() {
  // Signal the Watcher to exit.
  SetEvent(Terminate);
  HandlerThread.join();
  WatcherThread.join();
  CloseHandle(Terminate);
  CloseHandle(Overlapped.hEvent);
}

void DirectoryWatcherWindows::InitialScan() {
  std::unique_lock<std::mutex> lock(Mutex);
  Ready.wait(lock, [this] { return this->WatcherActive; });

  Callback(getAsFileEvents(scanDirectory(Path.data())), /*IsInitial=*/true);
}

void DirectoryWatcherWindows::WatcherThreadProc(HANDLE DirectoryHandle) {
  while (true) {
    // We do not guarantee subdirectories, but macOS already provides
    // subdirectories, might as well as ...
    BOOL WatchSubtree = TRUE;
    DWORD NotifyFilter = FILE_NOTIFY_CHANGE_FILE_NAME
                       | FILE_NOTIFY_CHANGE_DIR_NAME
                       | FILE_NOTIFY_CHANGE_SIZE
                       | FILE_NOTIFY_CHANGE_LAST_WRITE
                       | FILE_NOTIFY_CHANGE_CREATION;

    DWORD BytesTransferred;
    if (!ReadDirectoryChangesW(DirectoryHandle, Notifications.data(),
                               Notifications.size() * sizeof(DWORD),
                               WatchSubtree, NotifyFilter, &BytesTransferred,
                               &Overlapped, NULL)) {
      Q.emplace(DirectoryWatcher::Event::EventKind::WatcherGotInvalidated,
                "");
      break;
    }

    if (!WatcherActive) {
      std::unique_lock<std::mutex> lock(Mutex);
      WatcherActive = true;
    }
    Ready.notify_one();

    HANDLE Handles[2] = { Terminate, Overlapped.hEvent };
    switch (WaitForMultipleObjects(2, Handles, FALSE, INFINITE)) {
    case WAIT_OBJECT_0: // Terminate Request
    case WAIT_FAILED:   // Failure
      Q.emplace(DirectoryWatcher::Event::EventKind::WatcherGotInvalidated,
                "");
      (void)CloseHandle(DirectoryHandle);
      return;
    case WAIT_TIMEOUT:  // Spurious wakeup?
      continue;
    case WAIT_OBJECT_0 + 1: // Directory change
      break;
    }

    if (!GetOverlappedResult(DirectoryHandle, &Overlapped, &BytesTransferred,
                             FALSE)) {
      Q.emplace(DirectoryWatcher::Event::EventKind::WatchedDirRemoved,
                "");
      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 *I =
            (FILE_NOTIFY_INFORMATION *)Notifications.data();
         I;
         I = I->NextEntryOffset
              ? (FILE_NOTIFY_INFORMATION *)((CHAR *)I + I->NextEntryOffset)
              : NULL) {
      DirectoryWatcher::Event::EventKind Kind =
          DirectoryWatcher::Event::EventKind::WatcherGotInvalidated;
      switch (I->Action) {
      case FILE_ACTION_ADDED:
      case FILE_ACTION_MODIFIED:
      case FILE_ACTION_RENAMED_NEW_NAME:
        Kind = DirectoryWatcher::Event::EventKind::Modified;
        break;
      case FILE_ACTION_REMOVED:
      case FILE_ACTION_RENAMED_OLD_NAME:
        Kind = DirectoryWatcher::Event::EventKind::Removed;
        break;
      }

      SmallString<MAX_PATH> filename;
      sys::windows::UTF16ToUTF8(I->FileName, I->FileNameLength / sizeof(WCHAR),
                                filename);
      Q.emplace(Kind, filename);
    }
  }

  (void)CloseHandle(DirectoryHandle);
}

void DirectoryWatcherWindows::NotifierThreadProc(bool 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;
  }
}

auto error(DWORD ErrorCode) {
  DWORD Flags = FORMAT_MESSAGE_ALLOCATE_BUFFER
              | FORMAT_MESSAGE_FROM_SYSTEM
              | FORMAT_MESSAGE_IGNORE_INSERTS;

  LPSTR Buffer;
  if (!FormatMessageA(Flags, NULL, ErrorCode,
                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&Buffer,
                      0, NULL)) {
    return make_error<llvm::StringError>("error " + utostr(ErrorCode),
                                         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,
                                DirectoryWatcherCallback Receiver,
                                bool WaitForInitialSync) {
  if (Path.empty())
    llvm::report_fatal_error(
        "DirectoryWatcher::create can not accept an empty Path.");

  if (!sys::fs::is_directory(Path))
    llvm::report_fatal_error(
        "DirectoryWatcher::create can not accept a filepath.");

  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());

  DWORD DesiredAccess = FILE_LIST_DIRECTORY;
  DWORD ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
  DWORD CreationDisposition = OPEN_EXISTING;
  DWORD FlagsAndAttributes = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;

  HANDLE DirectoryHandle =
      CreateFileW(WidePath.data(), DesiredAccess, ShareMode,
                  /*lpSecurityAttributes=*/NULL, CreationDisposition,
                  FlagsAndAttributes, NULL);
  if (DirectoryHandle == INVALID_HANDLE_VALUE)
    return error(GetLastError());

  // NOTE: We use the watcher instance as a RAII object to discard the handles
  // for the directory in case of an error.  Hence, this is early allocated,
  // with the state being written directly to the watcher.
  return std::make_unique<DirectoryWatcherWindows>(
      DirectoryHandle, WaitForInitialSync, Receiver);
}