Game add-ons: Fix segfault when opening game

This fixes a segfault that occurs when moving an analog stick on game
open. The analog stick event is delivered while joysticks are being
connected/disconnected.

xbmc/games/addons/input/GameClientInput.cpp

@@ -34,6 +34,7 @@
 #include "guilib/GUIWindowManager.h"
 #include "guilib/WindowIDs.h"
 #include "input/joysticks/JoystickTypes.h"
+#include "peripherals/EventLockHandle.h"
 #include "peripherals/Peripherals.h"
 #include "threads/SingleLock.h"
 #include "utils/log.h"
@@ -392,8 +393,11 @@ bool CGameClientInput::OpenJoystick(const std::string &portAddress, const Contro
 
   if (bSuccess)
   {
+    PERIPHERALS::EventLockHandlePtr lock = CServiceBroker::GetPeripherals().RegisterEventLock();
+
     m_joysticks[portAddress].reset(new CGameClientJoystick(m_gameClient, portAddress, controller, m_struct.toAddon));
     ProcessJoysticks();
+
     return true;
   }
 
@@ -407,7 +411,12 @@ void CGameClientInput::CloseJoystick(const std::string &portAddress)
   {
     std::unique_ptr<CGameClientJoystick> joystick = std::move(it->second);
     m_joysticks.erase(it);
-    ProcessJoysticks();
+    {
+      PERIPHERALS::EventLockHandlePtr lock = CServiceBroker::GetPeripherals().RegisterEventLock();
+
+      ProcessJoysticks();
+      joystick.reset();
+    }
   }
 
   {
@@ -467,7 +476,10 @@ void CGameClientInput::Notify(const Observable& obs, const ObservableMessage msg
   {
   case ObservableMessagePeripheralsChanged:
   {
+    PERIPHERALS::EventLockHandlePtr lock = CServiceBroker::GetPeripherals().RegisterEventLock();
+
     ProcessJoysticks();
+
     break;
   }
   default:

xbmc/peripherals/CMakeLists.txt

@@ -1,8 +1,10 @@
-set(SOURCES EventPollHandle.cpp
+set(SOURCES EventLockHandle.cpp
+            EventPollHandle.cpp
             EventScanner.cpp
             Peripherals.cpp)
 
-set(HEADERS EventPollHandle.h
+set(HEADERS EventLockHandle.h
+            EventPollHandle.h
             EventScanner.h
             Peripherals.h
             PeripheralTypes.h)

xbmc/peripherals/EventLockHandle.cpp

@@ -0,0 +1,33 @@
+/*
+ *      Copyright (C) 2018 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "EventLockHandle.h"
+
+using namespace PERIPHERALS;
+
+CEventLockHandle::CEventLockHandle(IEventLockCallback &callback) :
+  m_callback(callback)
+{
+}
+
+CEventLockHandle::~CEventLockHandle(void)
+{
+  m_callback.ReleaseLock(*this);
+}

xbmc/peripherals/EventLockHandle.h

@@ -0,0 +1,59 @@
+/*
+ *      Copyright (C) 2018 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+namespace PERIPHERALS
+{
+  class CEventLockHandle;
+
+  /*!
+   * \brief Callback implemented by event scanner
+   */
+  class IEventLockCallback
+  {
+  public:
+    virtual ~IEventLockCallback(void) = default;
+
+    virtual void ReleaseLock(CEventLockHandle *handle) = 0;
+  };
+
+  /*!
+   * \brief Handle returned by the event scanner to disable event processing
+   *
+   * When held, this disables event processing.
+   */
+  class CEventLockHandle
+  {
+  public:
+    /*!
+     * \brief Create an event lock handle
+     */
+    CEventLockHandle(IEventLockCallback &callback);
+
+    /*!
+     * \brief Handle is automatically released when this class is destructed
+     */
+    ~CEventLockHandle(void);
+
+  private:
+    // Construction parameters
+    IEventLockCallback &m_callback;
+  };
+}

xbmc/peripherals/EventScanner.cpp

@@ -60,7 +60,7 @@ EventPollHandlePtr CEventScanner::RegisterPollHandle()
   EventPollHandlePtr handle(new CEventPollHandle(this));
 
   {
-    CSingleLock lock(m_mutex);
+    CSingleLock lock(m_handleMutex);
     m_activeHandles.insert(handle.get());
   }
 
@@ -72,7 +72,7 @@ EventPollHandlePtr CEventScanner::RegisterPollHandle()
 void CEventScanner::Activate(CEventPollHandle* handle)
 {
   {
-    CSingleLock lock(m_mutex);
+    CSingleLock lock(m_handleMutex);
     m_activeHandles.insert(handle);
   }
 
@@ -82,7 +82,7 @@ void CEventScanner::Activate(CEventPollHandle* handle)
 void CEventScanner::Deactivate(CEventPollHandle* handle)
 {
   {
-    CSingleLock lock(m_mutex);
+    CSingleLock lock(m_handleMutex);
     m_activeHandles.erase(handle);
   }
 
@@ -108,20 +108,48 @@ void CEventScanner::HandleEvents(bool bWait)
 void CEventScanner::Release(CEventPollHandle* handle)
 {
   {
-    CSingleLock lock(m_mutex);
+    CSingleLock lock(m_handleMutex);
     m_activeHandles.erase(handle);
   }
 
   CLog::Log(LOGDEBUG, "PERIPHERALS: Event poll handle released");
 }
 
+EventLockHandlePtr CEventScanner::RegisterLock()
+{
+  EventLockHandlePtr handle(new CEventLockHandle(*this));
+
+  {
+    CSingleLock lock(m_lockMutex);
+    m_activeLocks.insert(handle.get());
+  }
+
+  CLog::Log(LOGDEBUG, "PERIPHERALS: Event lock handle registered");
+
+  return handle;
+}
+
+void CEventScanner::ReleaseLock(CEventLockHandle &handle)
+{
+  {
+    CSingleLock lock(m_lockMutex);
+    m_activeLocks.erase(&handle);
+  }
+
+  CLog::Log(LOGDEBUG, "PERIPHERALS: Event lock handle released");
+}
+
 void CEventScanner::Process(void)
 {
   double nextScanMs = static_cast<double>(SystemClockMillis());
 
   while (!m_bStop)
   {
-    m_callback->ProcessEvents();
+    {
+      CSingleLock lock(m_lockMutex);
+      if (m_activeLocks.empty())
+        m_callback->ProcessEvents();
+    }
 
     m_scanFinishedEvent.Set();
 
@@ -147,7 +175,7 @@ double CEventScanner::GetScanIntervalMs() const
   bool bHasActiveHandle;
 
   {
-    CSingleLock lock(m_mutex);
+    CSingleLock lock(m_handleMutex);
     bHasActiveHandle = !m_activeHandles.empty();
   }
 

xbmc/peripherals/EventScanner.h

@@ -22,6 +22,7 @@
 
 #include <set>
 
+#include "EventLockHandle.h"
 #include "EventPollHandle.h"
 #include "PeripheralTypes.h"
 #include "threads/CriticalSection.h"
@@ -45,6 +46,7 @@ namespace PERIPHERALS
    * input is handled by registering for a polling handle.
    */
   class CEventScanner : public IEventPollCallback,
+                        public IEventLockCallback,
                         protected CThread
   {
   public:
@@ -57,12 +59,20 @@ namespace PERIPHERALS
 
     EventPollHandlePtr RegisterPollHandle();
 
+    /*!
+     * \brief Acquire a lock that prevents event processing while held
+     */
+    EventLockHandlePtr RegisterLock();
+
     // implementation of IEventPollCallback
     void Activate(CEventPollHandle *handle) override;
     void Deactivate(CEventPollHandle *handle) override;
     void HandleEvents(bool bWait) override;
     void Release(CEventPollHandle *handle) override;
 
+    // implementation of IEventLockCallback
+    void ReleaseLock(CEventLockHandle *handle) override;
+
   protected:
     // implementation of CThread
     void Process(void) override;
@@ -72,9 +82,11 @@ namespace PERIPHERALS
 
     IEventScannerCallback* const m_callback;
     std::set<void*>              m_activeHandles;
+    std::set<void*>              m_activeLocks;
     CEvent                       m_scanEvent;
     CEvent                       m_scanFinishedEvent;
-    CCriticalSection             m_mutex;
+    CCriticalSection             m_handleMutex;
+    CCriticalSection             m_lockMutex;
     CCriticalSection             m_pollMutex; // Prevent two poll handles from polling at once
   };
 }

xbmc/peripherals/PeripheralTypes.h

@@ -94,6 +94,9 @@ namespace PERIPHERALS
   class CEventPollHandle;
   typedef std::unique_ptr<CEventPollHandle> EventPollHandlePtr;
 
+  class CEventLockHandle;
+  using EventLockHandlePtr = std::unique_ptr<CEventLockHandle>;
+
   struct PeripheralID
   {
     int m_iVendorId;

xbmc/peripherals/Peripherals.cpp

@@ -777,6 +777,11 @@ bool CPeripherals::GetNextKeypress(float frameTime, CKey &key)
   return false;
 }
 
+EventLockHandlePtr CPeripherals::RegisterEventLock()
+{
+  return m_eventScanner.RegisterLock();
+}
+
 void CPeripherals::OnUserNotification()
 {
   if (!CServiceBroker::GetSettings().GetBool(CSettings::SETTING_INPUT_RUMBLENOTIFY))

xbmc/peripherals/Peripherals.h

@@ -238,6 +238,12 @@ namespace PERIPHERALS
      */
     EventPollHandlePtr RegisterEventPoller() { return m_eventScanner.RegisterPollHandle(); }
 
+    /*!
+     * @brief Register with the event scanner to disable event processing
+     * @return A handle that unregisters itself when expired
+     */
+    EventLockHandlePtr RegisterEventLock();
+
     /*!
      * 
      */