Ticket #1316: dir_watch_fam.cpp.patch

dir_watch_fam.cpp

@@ -28 +28 @@
 #include "lib/sysdep/sysdep.h"
 #include "lib/sysdep/dir_watch.h"
 #include "ps/CLogger.h"
+#include <sys/inotify.h>
 
-#if !CONFIG2_FAM
+// Stub implementations removed as inotify is part of the kernel.
 
-// stub implementations
-
-Status dir_watch_Add(const OsPath& UNUSED(path), PDirWatch& UNUSED(dirWatch))
-{
-    return INFO::OK;
-}
-
-Status dir_watch_Poll(DirWatchNotifications& UNUSED(notifications))
-{
-    return INFO::OK;
-}
-
-#else
-
-#include <fam.h>
-
-// FAMEvent is large (~4KB), so define a smaller structure to store events
 struct NotificationEvent
 {
     std::string filename;
-    void *userdata;
-    FAMCodes code;
+    uint32_t code;
+    int wd;
 };
 
 // To avoid deadlocks and slow synchronous reads, it's necessary to use a
-// separate thread for reading events from FAM.
+// separate thread for reading events from inotify.
 // So we just spawn a thread to push events into this list, then swap it out
 // when someone calls dir_watch_Poll.
 // (We assume STL memory allocation is thread-safe.)
@@ -72 +56 @@
 // FAM is broken or unavailable.
 static int initialized = 0;
 
-static FAMConnection fc;
+// Inotify file descriptor
+int inotifyfd;
 
+// FAM was able to give the whole path of the event thanks to *userdata
+// With inotify, using a Vector seems to be a good alternative.
+static std::vector<DirWatch> g_paths;
+
 struct DirWatch
 {
     DirWatch()
-        : reqnum(-1)
+        : reqnum(-1)
     {
     }
-
+    
     ~DirWatch()
     {
         ENSURE(initialized > 0);
-
-        FAMRequest req;
-        req.reqnum = reqnum;
-        FAMCancelMonitor(&fc, &req);
     }
-
+    
     OsPath path;
-    int reqnum;
+    int reqnum;     
 };
 
-
 // for atexit
 static void fam_deinit()
 {
-    FAMClose(&fc);
+    close(inotifyfd);
 
     pthread_cancel(g_event_loop_thread);
     // NOTE: POSIX threads are (by default) only cancellable inside particular
@@ -110 +94 @@
     pthread_join(g_event_loop_thread, NULL);
 }
 
+
 static void fam_event_loop_process_events()
 {
-    while(FAMPending(&fc) > 0)
+    // Buffer for reading the events.
+    // Need to be careful about overflow here.
+    char buffer[65535];
+    
+    // Event iterator
+    size_t buffer_i = 0;
+
+    // Total size of all the events
+    ssize_t r;
+    
+    // Size & struct for the current event
+    size_t event_size;
+    struct inotify_event *pevent;
+        
+    r = read(inotifyfd, buffer, 65535);
+    if(r <= 0)
+        return;
+    
+    while(buffer_i < r)
     {
-        FAMEvent e;
-        if(FAMNextEvent(&fc, &e) < 0)
-        {
-            debug_printf(L"FAMNextEvent error");
-            return;
-        }
-
         NotificationEvent ne;
-        ne.filename = e.filename;
-        ne.userdata = e.userdata;
-        ne.code = e.code;
-
+        pevent = (struct inotify_event *) &buffer[buffer_i];
+        event_size = offsetof(struct inotify_event, name) + pevent->len;
+        ne.wd = pevent->wd;
+        ne.filename = pevent->name;
+        ne.code = pevent->mask;     
         pthread_mutex_lock(&g_mutex);
         g_notifications.push_back(ne);
         pthread_mutex_unlock(&g_mutex);
+        
+        buffer_i += event_size;
     }
 }
 
 static void* fam_event_loop(void*)
 {
-    int famfd = FAMCONNECTION_GETFD(&fc);
-
     while(true)
     {
         fd_set fdrset;
         FD_ZERO(&fdrset);
-        FD_SET(famfd, &fdrset);
+        FD_SET(inotifyfd, &fdrset);
 
         // Block with select until there's events waiting
         // (Mustn't just block inside FAMNextEvent since fam will deadlock)
-        while(select(famfd+1, &fdrset, NULL, NULL, NULL) < 0)
+        while(select(inotifyfd+1, &fdrset, NULL, NULL, NULL) < 0)
         {
             if(errno == EINTR)
             {
                 // interrupted - try again
                 FD_ZERO(&fdrset);
-                FD_SET(famfd, &fdrset);
+                FD_SET(inotifyfd, &fdrset);
             }
             else if(errno == EBADF)
             {
                 // probably just lost the connection to FAM - kill the thread
-                debug_printf(L"lost connection to FAM");
+                debug_printf(L"Invalid file descriptor");
                 return NULL;
             }
             else
@@ -166 +163 @@
             }
         }
 
-        if(FD_ISSET(famfd, &fdrset))
+        if(FD_ISSET(inotifyfd, &fdrset))
             fam_event_loop_process_events();
     }
 }
@@ -179 +176 @@
 
     if(!initialized)
     {
-        if(FAMOpen2(&fc, "lib_res"))
+        if((inotifyfd = inotify_init()) < 0) 
         {
+            // Check for error ?
             initialized = -1;
-            LOGERROR(L"Error initializing FAM; hotloading will be disabled");
-            return ERR::FAIL;   // NOWARN
+            LOGERROR(L"Error initializing inotify file descriptor; hotloading will be disabled");
+            return ERR::FAIL;
         }
         
         if (pthread_create(&g_event_loop_thread, NULL, &fam_event_loop, NULL))
         {
             initialized = -1;
-            LOGERROR(L"Error creating FAM event loop thread; hotloading will be disabled");
+            LOGERROR(L"Error creating inotify event loop thread; hotloading will be disabled");
             return ERR::FAIL;   // NOWARN
         }
 
@@ -198 +196 @@
     }
 
     PDirWatch tmpDirWatch(new DirWatch);
+    int wd = -1;
 
-    // NOTE: It would be possible to use FAMNoExists iff we're building with Gamin
-    // (not FAM), to avoid a load of boring notifications when we add a directory,
-    // but it would only save tens of milliseconds of CPU time, so it's probably
-    // not worthwhile
-
-    FAMRequest req;
-    if(FAMMonitorDirectory(&fc, OsString(path).c_str(), &req, tmpDirWatch.get()) < 0)
+    if( (wd = inotify_add_watch(inotifyfd, OsString(path).c_str(), IN_CREATE | IN_DELETE | IN_MODIFY)) < 0)
     {
         debug_warn(L"res_watch_dir failed!");
-        WARN_RETURN(ERR::FAIL); // no way of getting error code?
+        WARN_RETURN(ERR::FAIL); // no way of getting error code?
     }
-
+    
     dirWatch.swap(tmpDirWatch);
     dirWatch->path = path;
-    dirWatch->reqnum = req.reqnum;
-
+    dirWatch->reqnum = wd;
+    g_paths.push_back(*dirWatch);
+    
     return INFO::OK;
 }
 
@@ -238 +232 @@
         DirWatchNotification::EType type;
         switch(polled_notifications[i].code)
         {
-        case FAMChanged:
+        case IN_MODIFY:
             type = DirWatchNotification::Changed;
             break;
-        case FAMCreated:
+        case IN_CREATE:
             type = DirWatchNotification::Created;
             break;
-        case FAMDeleted:
+        case IN_DELETE:
             type = DirWatchNotification::Deleted;
             break;
         default:
             continue;
         }
-        DirWatch* dirWatch = (DirWatch*)polled_notifications[i].userdata;
-        OsPath pathname = dirWatch->path / polled_notifications[i].filename;
-        notifications.push_back(DirWatchNotification(pathname, type));
+        
+        OsPath filename;
+        for(std::vector<DirWatch>::iterator it = g_paths.begin();
+            it != g_paths.end();
+            ++it)
+        {
+            if( (*it).reqnum == polled_notifications[i].wd)
+            {
+                filename = Path(OsString((*it).path).append(polled_notifications[i].filename));
+                break;
+            }
+        }
+        notifications.push_back(DirWatchNotification(filename, type));
     }
 
     // nothing new; try again later
     return INFO::OK;
 }
 
-#endif  // CONFIG2_FAM