core: Properly shutdown wl display (#7018)

* correctly destroy wayland globals

* properly shutdown and cleanup hyprland

* appease the nitpick gods and some comments

src/Compositor.cpp

@@ -43,7 +43,7 @@ int handleCritSignal(int signo, void* data) {
     Debug::log(LOG, "Hyprland received signal {}", signo);
 
     if (signo == SIGTERM || signo == SIGINT || signo == SIGKILL)
-        g_pCompositor->cleanup();
+        g_pCompositor->stopCompositor();
 
     return 0;
 }
@@ -193,6 +193,7 @@ CCompositor::CCompositor() {
 }
 
 CCompositor::~CCompositor() {
+    if (!m_bIsShuttingDown)
         cleanup();
 }
 
@@ -432,8 +433,16 @@ void CCompositor::cleanEnvironment() {
     }
 }
 
+void CCompositor::stopCompositor() {
+    Debug::log(LOG, "Hyprland is stopping!");
+
+    // this stops the wayland loop, wl_display_run
+    wl_display_terminate(m_sWLDisplay);
+    m_bIsShuttingDown = true;
+}
+
 void CCompositor::cleanup() {
-    if (!m_sWLDisplay || m_bIsShuttingDown)
+    if (!m_sWLDisplay)
         return;
 
     signal(SIGABRT, SIG_DFL);
@@ -507,13 +516,8 @@ void CCompositor::cleanup() {
     if (m_critSigSource)
         wl_event_source_remove(m_critSigSource);
 
-    wl_event_loop_destroy(m_sWLEventLoop);
+    // this frees all wayland resources, including sockets
-    wl_display_terminate(m_sWLDisplay);
+    wl_display_destroy(m_sWLDisplay);
-    m_sWLDisplay = nullptr;
-
-    std::string waylandSocket = std::string{getenv("XDG_RUNTIME_DIR")} + "/" + m_szWLDisplaySocket;
-    std::filesystem::remove(waylandSocket);
-    std::filesystem::remove(waylandSocket + ".lock");
 }
 
 void CCompositor::initManagers(eManagersInitStage stage) {

src/Compositor.hpp

@@ -71,6 +71,7 @@ class CCompositor {
 
     void                                      initServer(std::string socketName, int socketFd);
     void                                      startCompositor();
+    void                                      stopCompositor();
     void                                      cleanup();
     void                                      createLockFile();
     void                                      removeLockFile();

src/main.cpp

@@ -157,11 +157,9 @@ int main(int argc, char** argv) {
     // If all's good to go, start.
     g_pCompositor->startCompositor();
 
-    g_pCompositor->m_bIsShuttingDown = true;
+    g_pCompositor->cleanup();
 
-    // If we are here it means we got yote.
+    Debug::log(LOG, "Hyprland has reached the end.");
-    Debug::log(LOG, "Hyprland reached the end.");
-    g_pCompositor.reset();
 
     return EXIT_SUCCESS;
 }

src/managers/KeybindManager.cpp

@@ -1662,7 +1662,7 @@ void CKeybindManager::renameWorkspace(std::string args) {
 }
 
 void CKeybindManager::exitHyprland(std::string argz) {
-    g_pEventLoopManager->doLater([]() { g_pCompositor->cleanup(); });
+    g_pCompositor->stopCompositor();
 }
 
 void CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {

src/managers/ProtocolManager.cpp

@@ -166,3 +166,57 @@ CProtocolManager::CProtocolManager() {
     m_pGlobalShortcutsProtocolManager = std::make_unique<CGlobalShortcutsProtocolManager>();
     m_pScreencopyProtocolManager      = std::make_unique<CScreencopyProtocolManager>();
 }
+
+CProtocolManager::~CProtocolManager() {
+    // this is dumb but i don't want to replace all 600 PROTO with the right thing
+
+    // Output
+    PROTO::outputs.clear();
+
+    // Core
+    PROTO::seat.reset();
+    PROTO::data.reset();
+    PROTO::compositor.reset();
+    PROTO::subcompositor.reset();
+    PROTO::shm.reset();
+
+    // Extensions
+    PROTO::viewport.reset();
+    PROTO::tearing.reset();
+    PROTO::fractional.reset();
+    PROTO::xdgOutput.reset();
+    PROTO::cursorShape.reset();
+    PROTO::idleInhibit.reset();
+    PROTO::relativePointer.reset();
+    PROTO::xdgDecoration.reset();
+    PROTO::alphaModifier.reset();
+    PROTO::gamma.reset();
+    PROTO::foreignToplevel.reset();
+    PROTO::pointerGestures.reset();
+    PROTO::foreignToplevelWlr.reset();
+    PROTO::shortcutsInhibit.reset();
+    PROTO::textInputV3.reset();
+    PROTO::constraints.reset();
+    PROTO::outputPower.reset();
+    PROTO::activation.reset();
+    PROTO::idle.reset();
+    PROTO::sessionLock.reset();
+    PROTO::ime.reset();
+    PROTO::virtualKeyboard.reset();
+    PROTO::virtualPointer.reset();
+    PROTO::outputManagement.reset();
+    PROTO::serverDecorationKDE.reset();
+    PROTO::focusGrab.reset();
+    PROTO::tablet.reset();
+    PROTO::layerShell.reset();
+    PROTO::presentation.reset();
+    PROTO::xdgShell.reset();
+    PROTO::dataWlr.reset();
+    PROTO::primarySelection.reset();
+    PROTO::xwaylandShell.reset();
+
+    PROTO::lease.reset();
+    PROTO::sync.reset();
+    PROTO::mesaDRM.reset();
+    PROTO::linuxDma.reset();
+}

src/managers/ProtocolManager.hpp

@@ -12,6 +12,7 @@
 class CProtocolManager {
   public:
     CProtocolManager();
+    ~CProtocolManager();
 
     // TODO: rewrite to use the new protocol framework
     std::unique_ptr<CToplevelExportProtocolManager>  m_pToplevelExportProtocolManager;

src/managers/eventLoop/EventLoopManager.cpp

@@ -19,8 +19,14 @@ CEventLoopManager::CEventLoopManager(wl_display* display, wl_event_loop* wlEvent
 }
 
 CEventLoopManager::~CEventLoopManager() {
+    for (auto& eventSource : m_sWayland.aqEventSources) {
+        wl_event_source_remove(eventSource);
+    }
+
     if (m_sWayland.eventSource)
         wl_event_source_remove(m_sWayland.eventSource);
+    if (m_sIdle.eventSource)
+        wl_event_source_remove(m_sIdle.eventSource);
 }
 
 static int timerWrite(int fd, uint32_t mask, void* data) {

src/protocols/GlobalShortcuts.cpp

@@ -8,13 +8,20 @@ static void bindManagerInt(wl_client* client, void* data, uint32_t version, uint
 }
 
 static void handleDisplayDestroy(struct wl_listener* listener, void* data) {
-    g_pProtocolManager->m_pGlobalShortcutsProtocolManager->displayDestroy();
+    CGlobalShortcutsProtocolManager* proto = wl_container_of(listener, proto, m_liDisplayDestroy);
+    proto->displayDestroy();
 }
 
 void CGlobalShortcutsProtocolManager::displayDestroy() {
+    wl_list_remove(&m_liDisplayDestroy.link);
+    wl_list_init(&m_liDisplayDestroy.link);
     wl_global_destroy(m_pGlobal);
 }
 
+CGlobalShortcutsProtocolManager::~CGlobalShortcutsProtocolManager() {
+    displayDestroy();
+}
+
 CGlobalShortcutsProtocolManager::CGlobalShortcutsProtocolManager() {
     m_pGlobal = wl_global_create(g_pCompositor->m_sWLDisplay, &hyprland_global_shortcuts_manager_v1_interface, GLOBAL_SHORTCUTS_VERSION, this, bindManagerInt);
 

src/protocols/GlobalShortcuts.hpp

@@ -17,6 +17,8 @@ struct SShortcutClient {
 class CGlobalShortcutsProtocolManager {
   public:
     CGlobalShortcutsProtocolManager();
+    ~CGlobalShortcutsProtocolManager();
+
     void                   bindManager(wl_client* client, void* data, uint32_t version, uint32_t id);
     void                   displayDestroy();
 
@@ -29,11 +31,12 @@ class CGlobalShortcutsProtocolManager {
 
     std::vector<SShortcut> getAllShortcuts();
 
+    wl_listener            m_liDisplayDestroy;
+
   private:
     std::vector<std::unique_ptr<SShortcutClient>> m_vClients;
 
     SShortcutClient*                              clientFromWlClient(wl_client* client);
 
     wl_global*                                    m_pGlobal = nullptr;
-    wl_listener                                   m_liDisplayDestroy;
 };

src/protocols/Screencopy.cpp

@@ -16,15 +16,22 @@ static void bindManagerInt(wl_client* client, void* data, uint32_t version, uint
 }
 
 static void handleDisplayDestroy(struct wl_listener* listener, void* data) {
-    g_pProtocolManager->m_pScreencopyProtocolManager->displayDestroy();
+    CScreencopyProtocolManager* proto = wl_container_of(listener, proto, m_liDisplayDestroy);
+    proto->displayDestroy();
 }
 
 void CScreencopyProtocolManager::displayDestroy() {
+    wl_list_remove(&m_liDisplayDestroy.link);
+    wl_list_init(&m_liDisplayDestroy.link);
     wl_global_destroy(m_pGlobal);
 }
 
 static SScreencopyFrame* frameFromResource(wl_resource*);
 
+CScreencopyProtocolManager::~CScreencopyProtocolManager() {
+    displayDestroy();
+}
+
 CScreencopyProtocolManager::CScreencopyProtocolManager() {
 
     m_pGlobal = wl_global_create(g_pCompositor->m_sWLDisplay, &zwlr_screencopy_manager_v1_interface, SCREENCOPY_VERSION, this, bindManagerInt);

src/protocols/Screencopy.hpp

@@ -70,6 +70,7 @@ struct SScreencopyFrame {
 class CScreencopyProtocolManager {
   public:
     CScreencopyProtocolManager();
+    ~CScreencopyProtocolManager();
 
     void        bindManager(wl_client* client, void* data, uint32_t version, uint32_t id);
     void        removeClient(CScreencopyClient* client, bool force = false);
@@ -82,6 +83,8 @@ class CScreencopyProtocolManager {
 
     void        onOutputCommit(CMonitor* pMonitor);
 
+    wl_listener m_liDisplayDestroy;
+
   private:
     wl_global*                     m_pGlobal = nullptr;
     std::list<SScreencopyFrame>    m_lFrames;
@@ -90,8 +93,6 @@ class CScreencopyProtocolManager {
     SP<CEventLoopTimer>            m_pSoftwareCursorTimer;
     bool                           m_bTimerArmed = false;
 
-    wl_listener                    m_liDisplayDestroy;
-
     std::vector<SScreencopyFrame*> m_vFramesAwaitingWrite;
 
     SP<Aquamarine::IBuffer>        m_pLastMonitorBackBuffer;

src/protocols/TextInputV1.cpp

@@ -10,13 +10,20 @@ static void bindManagerInt(wl_client* client, void* data, uint32_t version, uint
 }
 
 static void handleDisplayDestroy(struct wl_listener* listener, void* data) {
-    g_pProtocolManager->m_pTextInputV1ProtocolManager->displayDestroy();
+    CTextInputV1ProtocolManager* proto = wl_container_of(listener, proto, m_liDisplayDestroy);
+    proto->displayDestroy();
 }
 
 void CTextInputV1ProtocolManager::displayDestroy() {
+    wl_list_remove(&m_liDisplayDestroy.link);
+    wl_list_init(&m_liDisplayDestroy.link);
     wl_global_destroy(m_pGlobal);
 }
 
+CTextInputV1ProtocolManager::~CTextInputV1ProtocolManager() {
+    displayDestroy();
+}
+
 CTextInputV1ProtocolManager::CTextInputV1ProtocolManager() {
     m_pGlobal = wl_global_create(g_pCompositor->m_sWLDisplay, &zwp_text_input_manager_v1_interface, TEXT_INPUT_VERSION, this, bindManagerInt);
 

src/protocols/TextInputV1.hpp

@@ -47,6 +47,7 @@ struct STextInputV1 {
 class CTextInputV1ProtocolManager {
   public:
     CTextInputV1ProtocolManager();
+    ~CTextInputV1ProtocolManager();
 
     void bindManager(wl_client* client, void* data, uint32_t version, uint32_t id);
     void createTI(wl_client* client, wl_resource* resource, uint32_t id);
@@ -67,9 +68,10 @@ class CTextInputV1ProtocolManager {
     void        handleCommitState(wl_client* client, wl_resource* resource, uint32_t serial);
     void        handleInvokeAction(wl_client* client, wl_resource* resource, uint32_t button, uint32_t index);
 
+    wl_listener m_liDisplayDestroy;
+
   private:
     wl_global*                                 m_pGlobal = nullptr;
-    wl_listener                                m_liDisplayDestroy;
 
     std::vector<std::unique_ptr<STextInputV1>> m_pClients;
 };

src/protocols/ToplevelExport.cpp

@@ -15,13 +15,20 @@ static void bindManagerInt(wl_client* client, void* data, uint32_t version, uint
 }
 
 static void handleDisplayDestroy(struct wl_listener* listener, void* data) {
-    g_pProtocolManager->m_pToplevelExportProtocolManager->displayDestroy();
+    CToplevelExportProtocolManager* proto = wl_container_of(listener, proto, m_liDisplayDestroy);
+    proto->displayDestroy();
 }
 
 void CToplevelExportProtocolManager::displayDestroy() {
+    wl_list_remove(&m_liDisplayDestroy.link);
+    wl_list_init(&m_liDisplayDestroy.link);
     wl_global_destroy(m_pGlobal);
 }
 
+CToplevelExportProtocolManager::~CToplevelExportProtocolManager() {
+    displayDestroy();
+}
+
 CToplevelExportProtocolManager::CToplevelExportProtocolManager() {
 
 #ifndef GLES32

src/protocols/ToplevelExport.hpp

@@ -13,6 +13,7 @@ class CWindow;
 class CToplevelExportProtocolManager {
   public:
     CToplevelExportProtocolManager();
+    ~CToplevelExportProtocolManager();
 
     void        bindManager(wl_client* client, void* data, uint32_t version, uint32_t id);
     void        captureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, PHLWINDOW handle);
@@ -23,13 +24,13 @@ class CToplevelExportProtocolManager {
     void        onWindowUnmap(PHLWINDOW pWindow);
     void        onOutputCommit(CMonitor* pMonitor);
 
+    wl_listener m_liDisplayDestroy;
+
   private:
     wl_global*                     m_pGlobal = nullptr;
     std::list<SScreencopyFrame>    m_lFrames;
     std::list<CScreencopyClient>   m_lClients;
 
-    wl_listener                    m_liDisplayDestroy;
-
     std::vector<SScreencopyFrame*> m_vFramesAwaitingWrite;
 
     void                           shareFrame(SScreencopyFrame* frame);

src/protocols/WaylandProtocol.cpp

@@ -6,7 +6,8 @@ static void bindManagerInternal(wl_client* client, void* data, uint32_t ver, uin
 }
 
 static void displayDestroyInternal(struct wl_listener* listener, void* data) {
-    ((IWaylandProtocol*)data)->onDisplayDestroy();
+    IWaylandProtocol* proto = wl_container_of(listener, proto, m_liDisplayDestroy);
+    proto->onDisplayDestroy();
 }
 
 void IWaylandProtocol::onDisplayDestroy() {

src/protocols/WaylandProtocol.hpp

@@ -26,8 +26,9 @@ class IWaylandProtocol {
         Debug::log(level, std::format("[{}] ", m_szName) + std::vformat(fmt.get(), std::make_format_args(args...)));
     };
 
+    wl_listener m_liDisplayDestroy;
+
   private:
     std::string m_szName;
     wl_global*  m_pGlobal = nullptr;
-    wl_listener m_liDisplayDestroy;
 };