Fix minor typo in wxDV_VERT_RULES documentation.

[wxWidgets.git] / src / unix / epolldispatcher.cpp

diff --git a/src/unix/epolldispatcher.cpp b/src/unix/epolldispatcher.cpp
index 011e8ae49ef050882b2809a818ae962b7b44457f..47f4dd4f56944803e274c466c480f437e55c577c 100644 (file)
--- a/src/unix/epolldispatcher.cpp
+++ b/src/unix/epolldispatcher.cpp
@@ -1,11 +1,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        src/common/epolldispatcher.cpp
+// Name:        src/unix/epolldispatcher.cpp

 // Purpose:     implements dispatcher for epoll_wait() call
 // Author:      Lukasz Michalski
 // Created:     April 2007
 // RCS-ID:      $Id$
 // Copyright:   (c) 2007 Lukasz Michalski
 // Purpose:     implements dispatcher for epoll_wait() call
 // Author:      Lukasz Michalski
 // Created:     April 2007
 // RCS-ID:      $Id$
 // Copyright:   (c) 2007 Lukasz Michalski

-// License:     wxWindows licence
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -19,20 +19,23 @@
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

-#ifdef HAVE_SYS_EPOLL_H
+#if wxUSE_EPOLL_DISPATCHER

 
 #include "wx/unix/private/epolldispatcher.h"
 #include "wx/unix/private.h"
 
 #include "wx/unix/private/epolldispatcher.h"
 #include "wx/unix/private.h"

-#include "wx/log.h"
-#include "wx/module.h"
+#include "wx/stopwatch.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/intl.h"
+#endif

 
 #include <sys/epoll.h>
 #include <errno.h>
 
 #include <sys/epoll.h>
 #include <errno.h>

+#include <unistd.h>

 
 #define wxEpollDispatcher_Trace wxT("epolldispatcher")
 
 
 #define wxEpollDispatcher_Trace wxT("epolldispatcher")
 

-static wxEpollDispatcher *gs_epollDispatcher = NULL;
-

 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================


@@ -41,27 +44,29 @@ static wxEpollDispatcher *gs_epollDispatcher = NULL;
 // debugging messages about it)
 static uint32_t GetEpollMask(int flags, int fd)
 {
 // debugging messages about it)
 static uint32_t GetEpollMask(int flags, int fd)
 {

+    wxUnusedVar(fd); // unused if wxLogTrace() disabled
+

     uint32_t ep = 0;
 
     if ( flags & wxFDIO_INPUT )
     {
         ep |= EPOLLIN;
         wxLogTrace(wxEpollDispatcher_Trace,
     uint32_t ep = 0;
 
     if ( flags & wxFDIO_INPUT )
     {
         ep |= EPOLLIN;
         wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Registered fd %d for input events"), fd);
+                   wxT("Registered fd %d for input events"), fd);

     }
 
     if ( flags & wxFDIO_OUTPUT )
     {
         ep |= EPOLLOUT;
         wxLogTrace(wxEpollDispatcher_Trace,
     }
 
     if ( flags & wxFDIO_OUTPUT )
     {
         ep |= EPOLLOUT;
         wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Registered fd %d for output events"), fd);
+                   wxT("Registered fd %d for output events"), fd);

     }
 
     if ( flags & wxFDIO_EXCEPTION )
     {
         ep |= EPOLLERR | EPOLLHUP;
         wxLogTrace(wxEpollDispatcher_Trace,
     }
 
     if ( flags & wxFDIO_EXCEPTION )
     {
         ep |= EPOLLERR | EPOLLHUP;
         wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Registered fd %d for exceptional events"), fd);
+                   wxT("Registered fd %d for exceptional events"), fd);

     }
 
     return ep;
     }
 
     return ep;


@@ -71,20 +76,37 @@ static uint32_t GetEpollMask(int flags, int fd)
 // wxEpollDispatcher
 // ----------------------------------------------------------------------------
 
 // wxEpollDispatcher
 // ----------------------------------------------------------------------------
 

-wxEpollDispatcher::wxEpollDispatcher()
+/* static */
+wxEpollDispatcher *wxEpollDispatcher::Create()

 {
 {

-    m_epollDescriptor = epoll_create(1024);
-    if ( m_epollDescriptor == -1 )
+    int epollDescriptor = epoll_create(1024);
+    if ( epollDescriptor == -1 )

     {
         wxLogSysError(_("Failed to create epoll descriptor"));
     {
         wxLogSysError(_("Failed to create epoll descriptor"));

+        return NULL;

     }
     }

+    wxLogTrace(wxEpollDispatcher_Trace,
+                   wxT("Epoll fd %d created"), epollDescriptor);
+    return new wxEpollDispatcher(epollDescriptor);

 }
 
 }
 

-bool wxEpollDispatcher::RegisterFD(int fd, wxFDIOHandler* handler, int flags)
+wxEpollDispatcher::wxEpollDispatcher(int epollDescriptor)

 {
 {

-    if ( !wxFDIODispatcher::RegisterFD(fd, handler, flags) )
-        return false;
+    wxASSERT_MSG( epollDescriptor != -1, wxT("invalid descriptor") );
+
+    m_epollDescriptor = epollDescriptor;
+}
+
+wxEpollDispatcher::~wxEpollDispatcher()
+{
+    if ( close(m_epollDescriptor) != 0 )
+    {
+        wxLogSysError(_("Error closing epoll descriptor"));
+    }
+}

 
 

+bool wxEpollDispatcher::RegisterFD(int fd, wxFDIOHandler* handler, int flags)
+{

     epoll_event ev;
     ev.events = GetEpollMask(flags, fd);
     ev.data.ptr = handler;
     epoll_event ev;
     ev.events = GetEpollMask(flags, fd);
     ev.data.ptr = handler;


@@ -97,15 +119,14 @@ bool wxEpollDispatcher::RegisterFD(int fd, wxFDIOHandler* handler, int flags)
 
         return false;
     }
 
         return false;
     }

+    wxLogTrace(wxEpollDispatcher_Trace,
+               wxT("Added fd %d (handler %p) to epoll %d"), fd, handler, m_epollDescriptor);

 
     return true;
 }
 
 bool wxEpollDispatcher::ModifyFD(int fd, wxFDIOHandler* handler, int flags)
 {
 
     return true;
 }
 
 bool wxEpollDispatcher::ModifyFD(int fd, wxFDIOHandler* handler, int flags)
 {

-    if ( !wxFDIODispatcher::ModifyFD(fd, handler, flags) )
-        return false;
-

     epoll_event ev;
     ev.events = GetEpollMask(flags, fd);
     ev.data.ptr = handler;
     epoll_event ev;
     ev.events = GetEpollMask(flags, fd);
     ev.data.ptr = handler;


@@ -119,15 +140,13 @@ bool wxEpollDispatcher::ModifyFD(int fd, wxFDIOHandler* handler, int flags)
         return false;
     }
 
         return false;
     }
 

+    wxLogTrace(wxEpollDispatcher_Trace,
+                wxT("Modified fd %d (handler: %p) on epoll %d"), fd, handler, m_epollDescriptor);

     return true;
 }
 
     return true;
 }
 

-wxFDIOHandler *wxEpollDispatcher::UnregisterFD(int fd, int flags)
+bool wxEpollDispatcher::UnregisterFD(int fd)

 {
 {

-    wxFDIOHandler * const handler = wxFDIODispatcher::UnregisterFD(fd, flags);
-    if ( !handler )
-        return NULL;
-

     epoll_event ev;
     ev.events = 0;
     ev.data.ptr = NULL;
     epoll_event ev;
     ev.events = 0;
     ev.data.ptr = NULL;


@@ -137,83 +156,93 @@ wxFDIOHandler *wxEpollDispatcher::UnregisterFD(int fd, int flags)
         wxLogSysError(_("Failed to unregister descriptor %d from epoll descriptor %d"),
                       fd, m_epollDescriptor);
     }
         wxLogSysError(_("Failed to unregister descriptor %d from epoll descriptor %d"),
                       fd, m_epollDescriptor);
     }

+    wxLogTrace(wxEpollDispatcher_Trace,
+                wxT("removed fd %d from %d"), fd, m_epollDescriptor);
+    return true;
+}
+
+int
+wxEpollDispatcher::DoPoll(epoll_event *events, int numEvents, int timeout) const
+{
+    // the code below relies on TIMEOUT_INFINITE being -1 so that we can pass
+    // timeout value directly to epoll_wait() which interprets -1 as meaning to
+    // wait forever and would need to be changed if the value of
+    // TIMEOUT_INFINITE ever changes
+    wxCOMPILE_TIME_ASSERT( TIMEOUT_INFINITE == -1, UpdateThisCode );
+
+    wxMilliClock_t timeEnd;
+    if ( timeout > 0 )
+        timeEnd = wxGetLocalTimeMillis();
+
+    int rc;
+    for ( ;; )
+    {
+        rc = epoll_wait(m_epollDescriptor, events, numEvents, timeout);
+        if ( rc != -1 || errno != EINTR )
+            break;

 
 

-    return handler;
+        // we got interrupted, update the timeout and restart
+        if ( timeout > 0 )
+        {
+            timeout = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis());
+            if ( timeout < 0 )
+                return 0;
+        }
+    }
+
+    return rc;

 }
 
 }
 

-void wxEpollDispatcher::RunLoop(int timeout)
+bool wxEpollDispatcher::HasPending() const
+{
+    epoll_event event;
+
+    // NB: it's not really clear if epoll_wait() can return a number greater
+    //     than the number of events passed to it but just in case it can, use
+    //     >= instead of == here, see #10397
+    return DoPoll(&event, 1, 0) >= 1;
+}
+
+int wxEpollDispatcher::Dispatch(int timeout)

 {
     epoll_event events[16];
 
 {
     epoll_event events[16];
 

-    const int e_num = epoll_wait
-                      (
-                        m_epollDescriptor,
-                        events,
-                        WXSIZEOF(events),
-                        timeout == TIMEOUT_INFINITE ? -1 : timeout
-                      );
+    const int rc = DoPoll(events, WXSIZEOF(events), timeout);

 
 

-    if ( e_num == -1 )
+    if ( rc == -1 )

     {
     {

-        if ( errno != EINTR )
-        {
-            wxLogSysError(_("Waiting for IO on epoll descriptor %d failed"),
-                          m_epollDescriptor);
-            return;
-        }
+        wxLogSysError(_("Waiting for IO on epoll descriptor %d failed"),
+                      m_epollDescriptor);
+        return -1;

     }
 
     }
 

-    for ( epoll_event *p = events; p < events + e_num; p++ )
+    int numEvents = 0;
+    for ( epoll_event *p = events; p < events + rc; p++ )

     {
         wxFDIOHandler * const handler = (wxFDIOHandler *)(p->data.ptr);
         if ( !handler )
         {
     {
         wxFDIOHandler * const handler = (wxFDIOHandler *)(p->data.ptr);
         if ( !handler )
         {

-            wxFAIL_MSG( _T("NULL handler in epoll_event?") );
+            wxFAIL_MSG( wxT("NULL handler in epoll_event?") );

             continue;
         }
 
             continue;
         }
 

-        if ( p->events & EPOLLIN )
+        // note that for compatibility with wxSelectDispatcher we call
+        // OnReadWaiting() on EPOLLHUP as this is what epoll_wait() returns
+        // when the write end of a pipe is closed while with select() the
+        // remaining pipe end becomes ready for reading when this happens
+        if ( p->events & (EPOLLIN | EPOLLHUP) )

             handler->OnReadWaiting();
             handler->OnReadWaiting();

-
-        if ( p->events & EPOLLOUT )
+        else if ( p->events & EPOLLOUT )

             handler->OnWriteWaiting();
             handler->OnWriteWaiting();

-
-        if ( p->events & (EPOLLERR | EPOLLHUP) )
+        else if ( p->events & EPOLLERR )

             handler->OnExceptionWaiting();
             handler->OnExceptionWaiting();

-    }
-}
+        else
+            continue;

 
 

-/* static */
-wxEpollDispatcher *wxEpollDispatcher::Get()
-{
-    if ( !gs_epollDispatcher )
-    {
-        gs_epollDispatcher = new wxEpollDispatcher;
-        if ( !gs_epollDispatcher->IsOk() )
-        {
-            delete gs_epollDispatcher;
-            gs_epollDispatcher = NULL;
-        }
+        numEvents++;

     }
 
     }
 

-    return gs_epollDispatcher;
+    return numEvents;

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// wxEpollDispatcherModule
-// ----------------------------------------------------------------------------
-
-class wxEpollDispatcherModule : public wxModule
-{
-public:
-    wxEpollDispatcherModule() { }
-
-    virtual bool OnInit() { return true; }
-    virtual void OnExit() { wxDELETE(gs_epollDispatcher); }
-
-    DECLARE_DYNAMIC_CLASS(wxEpollDispatcherModule)
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxEpollDispatcherModule, wxModule)
-
-#endif // HAVE_SYS_EPOLL_H
+#endif // wxUSE_EPOLL_DISPATCHER