base/files/file_path_watcher_kqueue.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file_path_watcher.h"
   6
   7 #include <fcntl.h>
   8 #include <sys/event.h>
   9 #include <sys/param.h>
  10
  11 #include <vector>
  12
  13 #include "base/bind.h"
  14 #include "base/file_util.h"
  15 #include "base/logging.h"
  16 #include "base/message_loop.h"
  17 #include "base/message_loop_proxy.h"
  18 #include "base/stringprintf.h"
  19
  20 // On some platforms these are not defined.
  21 #if !defined(EV_RECEIPT)
  22 #define EV_RECEIPT 0
  23 #endif
  24 #if !defined(O_EVTONLY)
  25 #define O_EVTONLY O_RDONLY
  26 #endif
  27
  28 namespace base {
  29 namespace files {
  30
  31 namespace {
  32
  33 // Mac-specific file watcher implementation based on kqueue.
  34 // Originally it was based on FSEvents so that the semantics were equivalent
  35 // on Linux, OSX and Windows where it was able to detect:
  36 // - file creation/deletion/modification in a watched directory
  37 // - file creation/deletion/modification for a watched file
  38 // - modifications to the paths to a watched object that would affect the
  39 //   object such as renaming/attibute changes etc.
  40 // The FSEvents version did all of the above except handling attribute changes
  41 // to path components. Unfortunately FSEvents appears to have an issue where the
  42 // current implementation (Mac OS X 10.6.7) sometimes drops events and doesn't
  43 // send notifications. See
  44 // http://code.google.com/p/chromium/issues/detail?id=54822#c31 for source that
  45 // will reproduce the problem. FSEvents also required having a CFRunLoop
  46 // backing the thread that it was running on, that caused added complexity
  47 // in the interfaces.
  48 // The kqueue implementation will handle all of the items in the list above
  49 // except for detecting modifications to files in a watched directory. It will
  50 // detect the creation and deletion of files, just not the modification of
  51 // files. It does however detect the attribute changes that the FSEvents impl
  52 // would miss.
  53 class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate,
  54                             public MessageLoopForIO::Watcher,
  55                             public MessageLoop::DestructionObserver {
  56  public:
  57   FilePathWatcherImpl() : kqueue_(-1) {}
  58
  59   // MessageLoopForIO::Watcher overrides.
  60   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
  61   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
  62
  63   // MessageLoop::DestructionObserver overrides.
  64   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
  65
  66   // FilePathWatcher::PlatformDelegate overrides.
  67   virtual bool Watch(const FilePath& path,
  68                      bool recursive,
  69                      FilePathWatcher::Delegate* delegate) OVERRIDE;
  70   virtual void Cancel() OVERRIDE;
  71
  72  protected:
  73   virtual ~FilePathWatcherImpl() {}
  74
  75  private:
  76   class EventData {
  77    public:
  78     EventData(const FilePath& path, const FilePath::StringType& subdir)
  79         : path_(path), subdir_(subdir) { }
  80     FilePath path_;  // Full path to this item.
  81     FilePath::StringType subdir_;  // Path to any sub item.
  82   };
  83   typedef std::vector<struct kevent> EventVector;
  84
  85   // Can only be called on |io_message_loop_|'s thread.
  86   virtual void CancelOnMessageLoopThread() OVERRIDE;
  87
  88   // Returns true if the kevent values are error free.
  89   bool AreKeventValuesValid(struct kevent* kevents, int count);
  90
  91   // Respond to a change of attributes of the path component represented by
  92   // |event|. Sets |target_file_affected| to true if |target_| is affected.
  93   // Sets |update_watches| to true if |events_| need to be updated.
  94   void HandleAttributesChange(const EventVector::iterator& event,
  95                               bool* target_file_affected,
  96                               bool* update_watches);
  97
  98   // Respond to a move of deletion of the path component represented by
  99   // |event|. Sets |target_file_affected| to true if |target_| is affected.
 100   // Sets |update_watches| to true if |events_| need to be updated.
 101   void HandleDeleteOrMoveChange(const EventVector::iterator& event,
 102                                 bool* target_file_affected,
 103                                 bool* update_watches);
 104
 105   // Respond to a creation of an item in the path component represented by
 106   // |event|. Sets |target_file_affected| to true if |target_| is affected.
 107   // Sets |update_watches| to true if |events_| need to be updated.
 108   void HandleCreateItemChange(const EventVector::iterator& event,
 109                               bool* target_file_affected,
 110                               bool* update_watches);
 111
 112   // Update |events_| with the current status of the system.
 113   // Sets |target_file_affected| to true if |target_| is affected.
 114   // Returns false if an error occurs.
 115   bool UpdateWatches(bool* target_file_affected);
 116
 117   // Fills |events| with one kevent per component in |path|.
 118   // Returns the number of valid events created where a valid event is
 119   // defined as one that has a ident (file descriptor) field != -1.
 120   static int EventsForPath(FilePath path, EventVector *events);
 121
 122   // Release a kevent generated by EventsForPath.
 123   static void ReleaseEvent(struct kevent& event);
 124
 125   // Returns a file descriptor that will not block the system from deleting
 126   // the file it references.
 127   static int FileDescriptorForPath(const FilePath& path);
 128
 129   // Closes |*fd| and sets |*fd| to -1.
 130   static void CloseFileDescriptor(int* fd);
 131
 132   // Returns true if kevent has open file descriptor.
 133   static bool IsKeventFileDescriptorOpen(const struct kevent& event) {
 134     return event.ident != static_cast<uintptr_t>(-1);
 135   }
 136
 137   static EventData* EventDataForKevent(const struct kevent& event) {
 138     return reinterpret_cast<EventData*>(event.udata);
 139   }
 140
 141   EventVector events_;
 142   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
 143   MessageLoopForIO::FileDescriptorWatcher kqueue_watcher_;
 144   scoped_refptr<FilePathWatcher::Delegate> delegate_;
 145   FilePath target_;
 146   int kqueue_;
 147
 148   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 149 };
 150
 151 void FilePathWatcherImpl::ReleaseEvent(struct kevent& event) {
 152   CloseFileDescriptor(reinterpret_cast<int*>(&event.ident));
 153   EventData* entry = EventDataForKevent(event);
 154   delete entry;
 155   event.udata = NULL;
 156 }
 157
 158 int FilePathWatcherImpl::EventsForPath(FilePath path, EventVector* events) {
 159   DCHECK(MessageLoopForIO::current());
 160   // Make sure that we are working with a clean slate.
 161   DCHECK(events->empty());
 162
 163   std::vector<FilePath::StringType> components;
 164   path.GetComponents(&components);
 165
 166   if (components.size() < 1) {
 167     return -1;
 168   }
 169
 170   int last_existing_entry = 0;
 171   FilePath built_path;
 172   bool path_still_exists = true;
 173   for(std::vector<FilePath::StringType>::iterator i = components.begin();
 174       i != components.end(); ++i) {
 175     if (i == components.begin()) {
 176       built_path = FilePath(*i);
 177     } else {
 178       built_path = built_path.Append(*i);
 179     }
 180     int fd = -1;
 181     if (path_still_exists) {
 182       fd = FileDescriptorForPath(built_path);
 183       if (fd == -1) {
 184         path_still_exists = false;
 185       } else {
 186         ++last_existing_entry;
 187       }
 188     }
 189     FilePath::StringType subdir = (i != (components.end() - 1)) ? *(i + 1) : "";
 190     EventData* data = new EventData(built_path, subdir);
 191     struct kevent event;
 192     EV_SET(&event, fd, EVFILT_VNODE, (EV_ADD | EV_CLEAR | EV_RECEIPT),
 193            (NOTE_DELETE | NOTE_WRITE | NOTE_ATTRIB |
 194             NOTE_RENAME | NOTE_REVOKE | NOTE_EXTEND), 0, data);
 195     events->push_back(event);
 196   }
 197   return last_existing_entry;
 198 }
 199
 200 int FilePathWatcherImpl::FileDescriptorForPath(const FilePath& path) {
 201   return HANDLE_EINTR(open(path.value().c_str(), O_EVTONLY));
 202 }
 203
 204 void FilePathWatcherImpl::CloseFileDescriptor(int *fd) {
 205   if (*fd == -1) {
 206     return;
 207   }
 208
 209   if (HANDLE_EINTR(close(*fd)) != 0) {
 210     DPLOG(ERROR) << "close";
 211   }
 212   *fd = -1;
 213 }
 214
 215 bool FilePathWatcherImpl::AreKeventValuesValid(struct kevent* kevents,
 216                                                int count) {
 217   if (count < 0) {
 218     DPLOG(ERROR) << "kevent";
 219     return false;
 220   }
 221   bool valid = true;
 222   for (int i = 0; i < count; ++i) {
 223     if (kevents[i].flags & EV_ERROR && kevents[i].data) {
 224       // Find the kevent in |events_| that matches the kevent with the error.
 225       EventVector::iterator event = events_.begin();
 226       for (; event != events_.end(); ++event) {
 227         if (event->ident == kevents[i].ident) {
 228           break;
 229         }
 230       }
 231       std::string path_name;
 232       if (event != events_.end()) {
 233         EventData* event_data = EventDataForKevent(*event);
 234         if (event_data != NULL) {
 235           path_name = event_data->path_.value();
 236         }
 237       }
 238       if (path_name.empty()) {
 239         path_name = base::StringPrintf(
 240             "fd %d", *reinterpret_cast<int*>(&kevents[i].ident));
 241       }
 242       DLOG(ERROR) << "Error: " << kevents[i].data << " for " << path_name;
 243       valid = false;
 244     }
 245   }
 246   return valid;
 247 }
 248
 249 void FilePathWatcherImpl::HandleAttributesChange(
 250     const EventVector::iterator& event,
 251     bool* target_file_affected,
 252     bool* update_watches) {
 253   EventVector::iterator next_event = event + 1;
 254   EventData* next_event_data = EventDataForKevent(*next_event);
 255   // Check to see if the next item in path is still accessible.
 256   int have_access = FileDescriptorForPath(next_event_data->path_);
 257   if (have_access == -1) {
 258     *target_file_affected = true;
 259     *update_watches = true;
 260     EventVector::iterator local_event(event);
 261     for (; local_event != events_.end(); ++local_event) {
 262       // Close all nodes from the event down. This has the side effect of
 263       // potentially rendering other events in |updates| invalid.
 264       // There is no need to remove the events from |kqueue_| because this
 265       // happens as a side effect of closing the file descriptor.
 266       CloseFileDescriptor(reinterpret_cast<int*>(&local_event->ident));
 267     }
 268   } else {
 269     CloseFileDescriptor(&have_access);
 270   }
 271 }
 272
 273 void FilePathWatcherImpl::HandleDeleteOrMoveChange(
 274     const EventVector::iterator& event,
 275     bool* target_file_affected,
 276     bool* update_watches) {
 277   *target_file_affected = true;
 278   *update_watches = true;
 279   EventVector::iterator local_event(event);
 280   for (; local_event != events_.end(); ++local_event) {
 281     // Close all nodes from the event down. This has the side effect of
 282     // potentially rendering other events in |updates| invalid.
 283     // There is no need to remove the events from |kqueue_| because this
 284     // happens as a side effect of closing the file descriptor.
 285     CloseFileDescriptor(reinterpret_cast<int*>(&local_event->ident));
 286   }
 287 }
 288
 289 void FilePathWatcherImpl::HandleCreateItemChange(
 290     const EventVector::iterator& event,
 291     bool* target_file_affected,
 292     bool* update_watches) {
 293   // Get the next item in the path.
 294   EventVector::iterator next_event = event + 1;
 295   EventData* next_event_data = EventDataForKevent(*next_event);
 296
 297   // Check to see if it already has a valid file descriptor.
 298   if (!IsKeventFileDescriptorOpen(*next_event)) {
 299     // If not, attempt to open a file descriptor for it.
 300     next_event->ident = FileDescriptorForPath(next_event_data->path_);
 301     if (IsKeventFileDescriptorOpen(*next_event)) {
 302       *update_watches = true;
 303       if (next_event_data->subdir_.empty()) {
 304         *target_file_affected = true;
 305       }
 306     }
 307   }
 308 }
 309
 310 bool FilePathWatcherImpl::UpdateWatches(bool* target_file_affected) {
 311   // Iterate over events adding kevents for items that exist to the kqueue.
 312   // Then check to see if new components in the path have been created.
 313   // Repeat until no new components in the path are detected.
 314   // This is to get around races in directory creation in a watched path.
 315   bool update_watches = true;
 316   while (update_watches) {
 317     size_t valid;
 318     for (valid = 0; valid < events_.size(); ++valid) {
 319       if (!IsKeventFileDescriptorOpen(events_[valid])) {
 320         break;
 321       }
 322     }
 323     if (valid == 0) {
 324       // The root of the file path is inaccessible?
 325       return false;
 326     }
 327
 328     EventVector updates(valid);
 329     int count = HANDLE_EINTR(kevent(kqueue_, &events_[0], valid, &updates[0],
 330                                     valid, NULL));
 331     if (!AreKeventValuesValid(&updates[0], count)) {
 332       return false;
 333     }
 334     update_watches = false;
 335     for (; valid < events_.size(); ++valid) {
 336       EventData* event_data = EventDataForKevent(events_[valid]);
 337       events_[valid].ident = FileDescriptorForPath(event_data->path_);
 338       if (IsKeventFileDescriptorOpen(events_[valid])) {
 339         update_watches = true;
 340         if (event_data->subdir_.empty()) {
 341           *target_file_affected = true;
 342         }
 343       } else {
 344         break;
 345       }
 346     }
 347   }
 348   return true;
 349 }
 350
 351 void FilePathWatcherImpl::OnFileCanReadWithoutBlocking(int fd) {
 352   DCHECK(MessageLoopForIO::current());
 353   DCHECK_EQ(fd, kqueue_);
 354   DCHECK(events_.size());
 355
 356   // Request the file system update notifications that have occurred and return
 357   // them in |updates|. |count| will contain the number of updates that have
 358   // occurred.
 359   EventVector updates(events_.size());
 360   struct timespec timeout = {0, 0};
 361   int count = HANDLE_EINTR(kevent(kqueue_, NULL, 0, &updates[0], updates.size(),
 362                                   &timeout));
 363
 364   // Error values are stored within updates, so check to make sure that no
 365   // errors occurred.
 366   if (!AreKeventValuesValid(&updates[0], count)) {
 367     delegate_->OnFilePathError(target_);
 368     Cancel();
 369     return;
 370   }
 371
 372   bool update_watches = false;
 373   bool send_notification = false;
 374
 375   // Iterate through each of the updates and react to them.
 376   for (int i = 0; i < count; ++i) {
 377     // Find our kevent record that matches the update notification.
 378     EventVector::iterator event = events_.begin();
 379     for (; event != events_.end(); ++event) {
 380       if (!IsKeventFileDescriptorOpen(*event) ||
 381           event->ident == updates[i].ident) {
 382         break;
 383       }
 384     }
 385     if (!IsKeventFileDescriptorOpen(*event) || event == events_.end()) {
 386       // The event may no longer exist in |events_| because another event
 387       // modified |events_| in such a way to make it invalid. For example if
 388       // the path is /foo/bar/bam and foo is deleted, NOTE_DELETE events for
 389       // foo, bar and bam will be sent. If foo is processed first, then
 390       // the file descriptors for bar and bam will already be closed and set
 391       // to -1 before they get a chance to be processed.
 392       continue;
 393     }
 394
 395     EventData* event_data = EventDataForKevent(*event);
 396
 397     // If the subdir is empty, this is the last item on the path and is the
 398     // target file.
 399     bool target_file_affected = event_data->subdir_.empty();
 400     if ((updates[i].fflags & NOTE_ATTRIB) && !target_file_affected) {
 401       HandleAttributesChange(event, &target_file_affected, &update_watches);
 402     }
 403     if (updates[i].fflags & (NOTE_DELETE | NOTE_REVOKE | NOTE_RENAME)) {
 404       HandleDeleteOrMoveChange(event, &target_file_affected, &update_watches);
 405     }
 406     if ((updates[i].fflags & NOTE_WRITE) && !target_file_affected) {
 407       HandleCreateItemChange(event, &target_file_affected, &update_watches);
 408     }
 409     send_notification |= target_file_affected;
 410   }
 411
 412   if (update_watches) {
 413     if (!UpdateWatches(&send_notification)) {
 414       delegate_->OnFilePathError(target_);
 415       Cancel();
 416     }
 417   }
 418
 419   if (send_notification) {
 420     delegate_->OnFilePathChanged(target_);
 421   }
 422 }
 423
 424 void FilePathWatcherImpl::OnFileCanWriteWithoutBlocking(int fd) {
 425   NOTREACHED();
 426 }
 427
 428 void FilePathWatcherImpl::WillDestroyCurrentMessageLoop() {
 429   CancelOnMessageLoopThread();
 430 }
 431
 432 bool FilePathWatcherImpl::Watch(const FilePath& path,
 433                                 bool recursive,
 434                                 FilePathWatcher::Delegate* delegate) {
 435   DCHECK(MessageLoopForIO::current());
 436   DCHECK(target_.value().empty());  // Can only watch one path.
 437   DCHECK(delegate);
 438   DCHECK_EQ(kqueue_, -1);
 439
 440   if (recursive) {
 441     // Recursive watch is not supported on this platform.
 442     NOTIMPLEMENTED();
 443     return false;
 444   }
 445
 446   delegate_ = delegate;
 447   target_ = path;
 448
 449   MessageLoop::current()->AddDestructionObserver(this);
 450   io_message_loop_ = base::MessageLoopProxy::current();
 451
 452   kqueue_ = kqueue();
 453   if (kqueue_ == -1) {
 454     DPLOG(ERROR) << "kqueue";
 455     return false;
 456   }
 457
 458   int last_entry = EventsForPath(target_, &events_);
 459   DCHECK_NE(last_entry, 0);
 460
 461   EventVector responses(last_entry);
 462
 463   int count = HANDLE_EINTR(kevent(kqueue_, &events_[0], last_entry,
 464                                   &responses[0], last_entry, NULL));
 465   if (!AreKeventValuesValid(&responses[0], count)) {
 466     // Calling Cancel() here to close any file descriptors that were opened.
 467     // This would happen in the destructor anyways, but FilePathWatchers tend to
 468     // be long lived, and if an error has occurred, there is no reason to waste
 469     // the file descriptors.
 470     Cancel();
 471     return false;
 472   }
 473
 474   return MessageLoopForIO::current()->WatchFileDescriptor(
 475       kqueue_, true, MessageLoopForIO::WATCH_READ, &kqueue_watcher_, this);
 476 }
 477
 478 void FilePathWatcherImpl::Cancel() {
 479   base::MessageLoopProxy* proxy = io_message_loop_.get();
 480   if (!proxy) {
 481     set_cancelled();
 482     return;
 483   }
 484   if (!proxy->BelongsToCurrentThread()) {
 485     proxy->PostTask(FROM_HERE,
 486                     base::Bind(&FilePathWatcherImpl::Cancel, this));
 487     return;
 488   }
 489   CancelOnMessageLoopThread();
 490 }
 491
 492 void FilePathWatcherImpl::CancelOnMessageLoopThread() {
 493   DCHECK(MessageLoopForIO::current());
 494   if (!is_cancelled()) {
 495     set_cancelled();
 496     kqueue_watcher_.StopWatchingFileDescriptor();
 497     CloseFileDescriptor(&kqueue_);
 498     std::for_each(events_.begin(), events_.end(), ReleaseEvent);
 499     events_.clear();
 500     io_message_loop_ = NULL;
 501     MessageLoop::current()->RemoveDestructionObserver(this);
 502     delegate_ = NULL;
 503   }
 504 }
 505
 506 }  // namespace
 507
 508 FilePathWatcher::FilePathWatcher() {
 509   impl_ = new FilePathWatcherImpl();
 510 }
 511
 512 }  // namespace files
 513 }  // namespace base