xref: /freebsd/contrib/llvm-project/clang/lib/DirectoryWatcher/mac/DirectoryWatcher-mac.cpp (revision ba3c1f5972d7b90feb6e6da47905ff2757e0fe57) 
1 //===- DirectoryWatcher-mac.cpp - Mac-platform directory watching ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "DirectoryScanner.h"
10 #include "clang/DirectoryWatcher/DirectoryWatcher.h"
11 
12 #include "llvm/ADT/STLExtras.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/Support/Error.h"
15 #include "llvm/Support/Path.h"
16 #include <CoreServices/CoreServices.h>
17 #include <TargetConditionals.h>
18 
19 using namespace llvm;
20 using namespace clang;
21 
22 #if TARGET_OS_OSX
23 
24 static void stopFSEventStream(FSEventStreamRef);
25 
26 namespace {
27 
28 /// This implementation is based on FSEvents API which implementation is
29 /// aggressively coallescing events. This can manifest as duplicate events.
30 ///
31 /// For example this scenario has been observed:
32 ///
33 /// create foo/bar
34 /// sleep 5 s
35 /// create DirectoryWatcherMac for dir foo
36 /// receive notification: bar EventKind::Modified
37 /// sleep 5 s
38 /// modify foo/bar
39 /// receive notification: bar EventKind::Modified
40 /// receive notification: bar EventKind::Modified
41 /// sleep 5 s
42 /// delete foo/bar
43 /// receive notification: bar EventKind::Modified
44 /// receive notification: bar EventKind::Modified
45 /// receive notification: bar EventKind::Removed
46 class DirectoryWatcherMac : public clang::DirectoryWatcher {
47 public:
48   DirectoryWatcherMac(
49       dispatch_queue_t Queue, FSEventStreamRef EventStream,
50       std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)>
51           Receiver,
52       llvm::StringRef WatchedDirPath)
53       : Queue(Queue), EventStream(EventStream), Receiver(Receiver),
54         WatchedDirPath(WatchedDirPath) {}
55 
56   ~DirectoryWatcherMac() override {
57     // FSEventStreamStop and Invalidate must be called after Start and
58     // SetDispatchQueue to follow FSEvents API contract. The call to Receiver
59     // also uses Queue to not race with the initial scan.
60     dispatch_sync(Queue, ^{
61       stopFSEventStream(EventStream);
62       EventStream = nullptr;
63       Receiver(
64           DirectoryWatcher::Event(
65               DirectoryWatcher::Event::EventKind::WatcherGotInvalidated, ""),
66           false);
67     });
68 
69     // Balance initial creation.
70     dispatch_release(Queue);
71   }
72 
73 private:
74   dispatch_queue_t Queue;
75   FSEventStreamRef EventStream;
76   std::function<void(llvm::ArrayRef<Event>, bool)> Receiver;
77   const std::string WatchedDirPath;
78 };
79 
80 struct EventStreamContextData {
81   std::string WatchedPath;
82   std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver;
83 
84   EventStreamContextData(
85       std::string &&WatchedPath,
86       std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)>
87           Receiver)
88       : WatchedPath(std::move(WatchedPath)), Receiver(Receiver) {}
89 
90   // Needed for FSEvents
91   static void dispose(const void *ctx) {
92     delete static_cast<const EventStreamContextData *>(ctx);
93   }
94 };
95 } // namespace
96 
97 constexpr const FSEventStreamEventFlags StreamInvalidatingFlags =
98     kFSEventStreamEventFlagUserDropped | kFSEventStreamEventFlagKernelDropped |
99     kFSEventStreamEventFlagMustScanSubDirs;
100 
101 constexpr const FSEventStreamEventFlags ModifyingFileEvents =
102     kFSEventStreamEventFlagItemCreated | kFSEventStreamEventFlagItemRenamed |
103     kFSEventStreamEventFlagItemModified;
104 
105 static void eventStreamCallback(ConstFSEventStreamRef Stream,
106                                 void *ClientCallBackInfo, size_t NumEvents,
107                                 void *EventPaths,
108                                 const FSEventStreamEventFlags EventFlags[],
109                                 const FSEventStreamEventId EventIds[]) {
110   auto *ctx = static_cast<EventStreamContextData *>(ClientCallBackInfo);
111 
112   std::vector<DirectoryWatcher::Event> Events;
113   for (size_t i = 0; i < NumEvents; ++i) {
114     StringRef Path = ((const char **)EventPaths)[i];
115     const FSEventStreamEventFlags Flags = EventFlags[i];
116 
117     if (Flags & StreamInvalidatingFlags) {
118       Events.emplace_back(DirectoryWatcher::Event{
119           DirectoryWatcher::Event::EventKind::WatcherGotInvalidated, ""});
120       break;
121     } else if (!(Flags & kFSEventStreamEventFlagItemIsFile)) {
122       // Subdirectories aren't supported - if some directory got removed it
123       // must've been the watched directory itself.
124       if ((Flags & kFSEventStreamEventFlagItemRemoved) &&
125           Path == ctx->WatchedPath) {
126         Events.emplace_back(DirectoryWatcher::Event{
127             DirectoryWatcher::Event::EventKind::WatchedDirRemoved, ""});
128         Events.emplace_back(DirectoryWatcher::Event{
129             DirectoryWatcher::Event::EventKind::WatcherGotInvalidated, ""});
130         break;
131       }
132       // No support for subdirectories - just ignore everything.
133       continue;
134     } else if (Flags & kFSEventStreamEventFlagItemRemoved) {
135       Events.emplace_back(DirectoryWatcher::Event::EventKind::Removed,
136                           llvm::sys::path::filename(Path));
137       continue;
138     } else if (Flags & ModifyingFileEvents) {
139       if (!getFileStatus(Path).has_value()) {
140         Events.emplace_back(DirectoryWatcher::Event::EventKind::Removed,
141                             llvm::sys::path::filename(Path));
142       } else {
143         Events.emplace_back(DirectoryWatcher::Event::EventKind::Modified,
144                             llvm::sys::path::filename(Path));
145       }
146       continue;
147     }
148 
149     // default
150     Events.emplace_back(DirectoryWatcher::Event{
151         DirectoryWatcher::Event::EventKind::WatcherGotInvalidated, ""});
152     llvm_unreachable("Unknown FSEvent type.");
153   }
154 
155   if (!Events.empty()) {
156     ctx->Receiver(Events, /*IsInitial=*/false);
157   }
158 }
159 
160 FSEventStreamRef createFSEventStream(
161     StringRef Path,
162     std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver,
163     dispatch_queue_t Queue) {
164   if (Path.empty())
165     return nullptr;
166 
167   CFMutableArrayRef PathsToWatch = [&]() {
168     CFMutableArrayRef PathsToWatch =
169         CFArrayCreateMutable(nullptr, 0, &kCFTypeArrayCallBacks);
170     CFStringRef CfPathStr =
171         CFStringCreateWithBytes(nullptr, (const UInt8 *)Path.data(),
172                                 Path.size(), kCFStringEncodingUTF8, false);
173     CFArrayAppendValue(PathsToWatch, CfPathStr);
174     CFRelease(CfPathStr);
175     return PathsToWatch;
176   }();
177 
178   FSEventStreamContext Context = [&]() {
179     std::string RealPath;
180     {
181       SmallString<128> Storage;
182       StringRef P = llvm::Twine(Path).toNullTerminatedStringRef(Storage);
183       char Buffer[PATH_MAX];
184       if (::realpath(P.begin(), Buffer) != nullptr)
185         RealPath = Buffer;
186       else
187         RealPath = Path.str();
188     }
189 
190     FSEventStreamContext Context;
191     Context.version = 0;
192     Context.info = new EventStreamContextData(std::move(RealPath), Receiver);
193     Context.retain = nullptr;
194     Context.release = EventStreamContextData::dispose;
195     Context.copyDescription = nullptr;
196     return Context;
197   }();
198 
199   FSEventStreamRef Result = FSEventStreamCreate(
200       nullptr, eventStreamCallback, &Context, PathsToWatch,
201       kFSEventStreamEventIdSinceNow, /* latency in seconds */ 0.0,
202       kFSEventStreamCreateFlagFileEvents | kFSEventStreamCreateFlagNoDefer);
203   CFRelease(PathsToWatch);
204 
205   return Result;
206 }
207 
208 void stopFSEventStream(FSEventStreamRef EventStream) {
209   if (!EventStream)
210     return;
211   FSEventStreamStop(EventStream);
212   FSEventStreamInvalidate(EventStream);
213   FSEventStreamRelease(EventStream);
214 }
215 
216 llvm::Expected<std::unique_ptr<DirectoryWatcher>> clang::DirectoryWatcher::create(
217     StringRef Path,
218     std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver,
219     bool WaitForInitialSync) {
220   dispatch_queue_t Queue =
221       dispatch_queue_create("DirectoryWatcher", DISPATCH_QUEUE_SERIAL);
222 
223   if (Path.empty())
224     llvm::report_fatal_error(
225         "DirectoryWatcher::create can not accept an empty Path.");
226 
227   auto EventStream = createFSEventStream(Path, Receiver, Queue);
228   assert(EventStream && "EventStream expected to be non-null");
229 
230   std::unique_ptr<DirectoryWatcher> Result =
231       std::make_unique<DirectoryWatcherMac>(Queue, EventStream, Receiver, Path);
232 
233   // We need to copy the data so the lifetime is ok after a const copy is made
234   // for the block.
235   const std::string CopiedPath = Path.str();
236 
237   auto InitWork = ^{
238     // We need to start watching the directory before we start scanning in order
239     // to not miss any event. By dispatching this on the same serial Queue as
240     // the FSEvents will be handled we manage to start watching BEFORE the
241     // inital scan and handling events ONLY AFTER the scan finishes.
242     FSEventStreamSetDispatchQueue(EventStream, Queue);
243     FSEventStreamStart(EventStream);
244     Receiver(getAsFileEvents(scanDirectory(CopiedPath)), /*IsInitial=*/true);
245   };
246 
247   if (WaitForInitialSync) {
248     dispatch_sync(Queue, InitWork);
249   } else {
250     dispatch_async(Queue, InitWork);
251   }
252 
253   return Result;
254 }
255 
256 #else // TARGET_OS_OSX
257 
258 llvm::Expected<std::unique_ptr<DirectoryWatcher>>
259 clang::DirectoryWatcher::create(
260     StringRef Path,
261     std::function<void(llvm::ArrayRef<DirectoryWatcher::Event>, bool)> Receiver,
262     bool WaitForInitialSync) {
263   return llvm::make_error<llvm::StringError>(
264       "DirectoryWatcher is not implemented for this platform!",
265       llvm::inconvertibleErrorCode());
266 }
267 
268 #endif // TARGET_OS_OSX
269