From 107b9bcb70e785c2d12515e38b8b296eea7ab8d8 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 20 May 2015 10:56:09 -0400
Subject: MAINT-5232: Introduce SUBSYSTEM_CLEANUP() macro and use it for
 existing LLSomeClass::cleanupClass() calls. This logs the fact of making the
 call, as well as making it.

---
 indra/llcommon/llcleanup.h | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 indra/llcommon/llcleanup.h

(limited to 'indra/llcommon/llcleanup.h')

diff --git a/indra/llcommon/llcleanup.h b/indra/llcommon/llcleanup.h
new file mode 100644
index 0000000000..8eda9a7fb3
--- /dev/null
+++ b/indra/llcommon/llcleanup.h
@@ -0,0 +1,30 @@
+/**
+ * @file   llcleanup.h
+ * @author Nat Goodspeed
+ * @date   2015-05-20
+ * @brief  Mechanism for cleaning up subsystem resources
+ * 
+ * $LicenseInfo:firstyear=2015&license=viewerlgpl$
+ * Copyright (c) 2015, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLCLEANUP_H)
+#define LL_LLCLEANUP_H
+
+#include "llerror.h"
+
+// Instead of directly calling SomeClass::cleanupClass(), use
+// SUBSYSTEM_CLEANUP(SomeClass);
+// This logs the call as well as performing it. That gives us a baseline
+// subsystem shutdown order against which to compare subsequent dynamic
+// shutdown schemes.
+#define SUBSYSTEM_CLEANUP(CLASSNAME)                                    \
+    do {                                                                \
+        LL_INFOS("Cleanup") << "Calling " #CLASSNAME "::cleanupClass()" << LL_ENDL; \
+        CLASSNAME::cleanupClass();                                      \
+    } while (0)
+// Use ancient do { ... } while (0) macro trick to permit a block of
+// statements with the same syntax as a single statement.
+
+#endif /* ! defined(LL_LLCLEANUP_H) */
-- 
cgit v1.2.3


From dcdccb3ef1b42b36042fa6f3fe61849124e1728f Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 30 Aug 2016 16:28:21 -0400
Subject: MAINT-5232: Move "llerror.h" out of llcleanup.h, llinitdestroyclass.h

Introduce corresponding llcleanup.cpp, llinitdestroyclass.cpp modules to
contain code that performs logging calls.

Track class::method names for LLInitClass<T> and LLDestroyClass<T> subclasses,
and log them when called. The order in which these calls occur could be
relevant to bugs, and could surface the need to convert to LLSingleton
dependencies.
---
 indra/llcommon/llcleanup.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'indra/llcommon/llcleanup.h')

diff --git a/indra/llcommon/llcleanup.h b/indra/llcommon/llcleanup.h
index 8eda9a7fb3..a319171b5f 100644
--- a/indra/llcommon/llcleanup.h
+++ b/indra/llcommon/llcleanup.h
@@ -12,7 +12,7 @@
 #if ! defined(LL_LLCLEANUP_H)
 #define LL_LLCLEANUP_H
 
-#include "llerror.h"
+#include <boost/current_function.hpp>
 
 // Instead of directly calling SomeClass::cleanupClass(), use
 // SUBSYSTEM_CLEANUP(SomeClass);
@@ -21,10 +21,13 @@
 // shutdown schemes.
 #define SUBSYSTEM_CLEANUP(CLASSNAME)                                    \
     do {                                                                \
-        LL_INFOS("Cleanup") << "Calling " #CLASSNAME "::cleanupClass()" << LL_ENDL; \
+        log_subsystem_cleanup(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, #CLASSNAME); \
         CLASSNAME::cleanupClass();                                      \
     } while (0)
 // Use ancient do { ... } while (0) macro trick to permit a block of
 // statements with the same syntax as a single statement.
 
+void log_subsystem_cleanup(const char* file, int line, const char* function,
+                           const char* classname);
+
 #endif /* ! defined(LL_LLCLEANUP_H) */
-- 
cgit v1.2.3