Ticket #1862: profiler2.patch

binaries/data/config/default.cfg

@@ -41 +41 @@
 ; Force a non-standard bit depth (if 0 then use the current desktop bit depth)
 bpp = 0
 
+; HTTP profiler server binding
+profiler2.listen_port = "127.0.0.1:8000"
+
 ; System settings:
 
 waternormals = true
@@ -313 +316 @@
 ; > PROFILER
 hotkey.profile.toggle = "F11"               ; Enable/disable real-time profiler
 hotkey.profile.save = "Shift+F11"           ; Save current profiler data to logs/profile.txt
-hotkey.profile2.enable = "F11"              ; Enable HTTP/GPU modes for new profiler
+hotkey.profile2.enable = "F11"              ; Enable GPU mode for new profiler
+hotkey.profile2.toggle_http = "Ctrl+F11"    ; Enable or disable HTTP mode for new profiler
 
 profiler2.http.autoenable = false           ; Enable HTTP server output at startup (default off for security/performance)
 profiler2.script.enable = false             ; Enable Javascript profiling. Needs to be set before startup and can't be changed later. (default off for performance)

source/main.cpp

@@ -164 +164 @@
         else if (hotkey == "profile2.enable")
         {
             g_Profiler2.EnableGPU();
-            g_Profiler2.EnableHTTP();
             return IN_HANDLED;
         }
+        else if (hotkey == "profile2.toggle_http")
+        {
+            g_Profiler2.ToggleHTTP();
+            return IN_HANDLED;
+        }
         break;
     }
 

source/ps/Profiler2.cpp

@@ -23 +23 @@
 #include "precompiled.h"
 
 #include "Profiler2.h"
+#include "ConfigDB.h"
 
 #include "lib/allocators/shared_ptr.h"
 #include "ps/CLogger.h"
@@ -154 +155 @@
     m_GPU = new CProfiler2GPU(*this);
 }
 
-void CProfiler2::EnableHTTP()
+bool CProfiler2::EnableHTTP()
 {
     ENSURE(m_Initialised);
 
     // Ignore multiple enablings
     if (m_MgContext)
-        return;
+    {
+        LOGWARNING(L"HTTP profiling server already enabled.");
+        return true;
+    }
 
+    const char *listening_ports = NULL;
+    CConfigValue *listening_ports_cfg = g_ConfigDB.GetValue(CFG_DEFAULT, "profiler2.listen_port");
+    if (listening_ports_cfg)
+        listening_ports = listening_ports_cfg->m_String.c_str();
+    else
+        listening_ports = "127.0.0.1:8000";
     const char *options[] = {
-        "listening_ports", "127.0.0.1:8000", // bind to localhost for security
+        "listening_ports", listening_ports,
         "num_threads", "6", // enough for the browser's parallel connection limit
         NULL
     };
     m_MgContext = mg_start(MgCallback, this, options);
-    ENSURE(m_MgContext);
+    if (!m_MgContext)
+    {
+        mg_error error = mg_get_last_error();
+        LOGERROR(L"Failed to start HTTP profiling server on %hs, mg_error: %hs", listening_ports, mg_get_error_string(error));
+    }
+    else
+    {
+        LOGWARNING(L"Started HTTP profiling server on %hs", listening_ports);
+    }
+    return IsHTTPEnabled();
 }
 
 void CProfiler2::EnableGPU()
@@ -183 +202 @@
     SAFE_DELETE(m_GPU);
 }
 
-void CProfiler2::Shutdown()
+void CProfiler2::ShutdownHTTP()
 {
     ENSURE(m_Initialised);
 
-    ENSURE(!m_GPU); // must shutdown GPU before profiler
-
     if (m_MgContext)
     {
+        LOGWARNING(L"Shutting down HTTP profiling server.");
         mg_stop(m_MgContext);
         m_MgContext = NULL;
     }
+}
 
+void CProfiler2::ToggleHTTP()
+{
+    ENSURE(m_Initialised);
+
+    if (IsHTTPEnabled())
+    {
+        ShutdownHTTP();
+    }
+    else
+    {
+        EnableHTTP();
+    }
+}
+
+void CProfiler2::Shutdown()
+{
+    ENSURE(m_Initialised);
+
+    ENSURE(!m_GPU); // must shutdown GPU before profiler
+
+    ShutdownHTTP();
+
     // TODO: free non-NULL keys, instead of leaking them
 
     int err = pthread_key_delete(m_TLS);

source/ps/Profiler2.h

@@ -261 +261 @@
      * (Disabled by default for security and performance
      * and to avoid annoying a firewall.)
      */
-    void EnableHTTP();
+    bool EnableHTTP();
 
     /**
      * Call in main thread to enable the GPU profiling support,
@@ -276 +276 @@
     void ShutdownGPU();
 
     /**
+     * Call in main thread to shut down the HTTP server.
+     */
+    void ShutdownHTTP();
+
+    /**
+     * Call in main thread to shut down or start the HTTP server.
+     */
+    void ToggleHTTP();
+
+    /**
+     * Call in any thread to get HTTP server status.
+     */
+    bool IsHTTPEnabled() { return m_MgContext != NULL; }
+
+    /**
      * Call in main thread to shut everything down.
      * All other profiled threads should have been terminated already.
      */

source/third_party/mongoose/mongoose.cpp

@@ -602 +602 @@
   return err == 0 ? "" : ERR_error_string(err, NULL);
 }
 
+// last internal error
+static mg_error last_error = MG_ERROR_NONE;
+
+// Return last encountered error. Only mg_start produces such errors at the moment.
+enum mg_error mg_get_last_error()
+{
+    mg_error error = last_error;
+    last_error = MG_ERROR_NONE;
+    return error;
+}
+
+// Returns description of error code.
+const char *mg_get_error_string(mg_error error_code)
+{
+    switch (error_code)
+    {
+    case MG_ERROR_NONE:
+        return "MG_ERROR_NONE";
+    case MG_START_INVALID_OPTION:
+        return "MG_START_INVALID_OPTION (some invalid option was provided)";
+    case MG_START_OPTION_IS_NULL:
+        return "MG_START_OPTION_IS_NULL (option value was NULL)";
+    case MG_START_GLOBAL_PASSWORDS_OPTION_ERROR:
+        return "MG_START_GLOBAL_PASSWORDS_OPTION_ERROR (failed to load global passwords file or directory)";
+    case MG_START_LISTENING_PORTS_INVALID:
+        return "MG_START_LISTENING_PORTS_INVALID (invalid format of listening_ports option)";
+    case MG_START_LISTENING_PORTS_SSL_ERROR:
+        return "MG_START_LISTENING_PORTS_SSL_ERROR (error when trying to start listening to SSL port)";
+    case MG_START_LISTENING_PORTS_CANNOT_BIND:
+        return "MG_START_LISTENING_PORTS_CANNOT_BIND (failed to bind to one of specified ports)";
+    case MG_START_LISTENING_PORTS_LISTENER_ALLOC_ERROR: 
+        return "MG_START_LISTENING_PORTS_LISTENER_ALLOC_ERROR (not enough memory to initialize listener)";
+    default:
+        static char buf[4];
+        sprintf(buf, "%d", error_code);
+        return buf;
+    }
+}
+
 // Return fake connection structure. Used for logging, if connection
 // is not applicable at the moment of logging.
 static struct mg_connection *fc(struct mg_context *ctx) {
@@ -3472 +3511 @@
     if (!parse_port_string(&vec, &so)) {
       cry(fc(ctx), "%s: %.*s: invalid port spec. Expecting list of: %s",
           __func__, (int) vec.len, vec.ptr, "[IP_ADDRESS:]PORT[s|p]");
+      last_error = MG_START_LISTENING_PORTS_INVALID;
       success = 0;
     } else if (so.is_ssl && ctx->ssl_ctx == NULL) {
       cry(fc(ctx), "Cannot add SSL socket, is -ssl_certificate option set?");
+      last_error = MG_START_LISTENING_PORTS_SSL_ERROR;
       success = 0;
     } else if ((sock = socket(PF_INET, SOCK_STREAM, 6)) == INVALID_SOCKET ||
 #if !defined(_WIN32)
@@ -3497 +3538 @@
       closesocket(sock);
       cry(fc(ctx), "%s: cannot bind to %.*s: %s", __func__,
           (int) vec.len, vec.ptr, strerror(ERRNO));
+      last_error = MG_START_LISTENING_PORTS_CANNOT_BIND;
       success = 0;
     } else if ((listener = (struct socket *)
                 calloc(1, sizeof(*listener))) == NULL) {
       closesocket(sock);
       cry(fc(ctx), "%s: %s", __func__, strerror(ERRNO));
+      last_error = MG_START_LISTENING_PORTS_LISTENER_ALLOC_ERROR;
       success = 0;
     } else {
       *listener = so;
@@ -3786 +3829 @@
 static int set_gpass_option(struct mg_context *ctx) {
   struct mgstat mgstat;
   const char *path = ctx->config[GLOBAL_PASSWORDS_FILE];
-  return path == NULL || mg_stat(path, &mgstat) == 0;
+  bool success = path == NULL || mg_stat(path, &mgstat) == 0;
+  if (!success)
+      last_error = MG_START_GLOBAL_PASSWORDS_OPTION_ERROR;
+  return success;
 }
 
 static int set_acl_option(struct mg_context *ctx) {
@@ -4237 +4283 @@
     if ((i = get_option_index(name)) == -1) {
       cry(fc(ctx), "Invalid option: %s", name);
       free_context(ctx);
+      last_error = MG_START_INVALID_OPTION;
       return NULL;
     } else if ((value = *options++) == NULL) {
       cry(fc(ctx), "%s: option value cannot be NULL", name);
       free_context(ctx);
+      last_error = MG_START_OPTION_IS_NULL;
       return NULL;
     }
     ctx->config[i] = mg_strdup(value);
@@ -4270 +4318 @@
 #endif
       !set_acl_option(ctx)) {
     free_context(ctx);
+    // do not set last_error here, set_xxx_option functions should take care of it.
     return NULL;
   }
 

source/third_party/mongoose/mongoose.h

@@ -60 +60 @@
                     // SSL context is passed to the callback function.
 };
 
+// Various errors that could be reported by Mongoose. Purpose is to extend error reporting.
+enum mg_error {
+    MG_ERROR_NONE,
+    
+    // errors after mg_start
+    MG_START_INVALID_OPTION,                        // some invalid option was provided
+    MG_START_OPTION_IS_NULL,                        // option value was NULL
+    MG_START_GLOBAL_PASSWORDS_OPTION_ERROR,         // failed to load global passwords file or directory
+    MG_START_LISTENING_PORTS_INVALID,               // invalid format of listening_ports option
+    MG_START_LISTENING_PORTS_SSL_ERROR,             // error when trying to start listening to SSL port
+    MG_START_LISTENING_PORTS_CANNOT_BIND,           // failed to bind to one of specified ports
+    MG_START_LISTENING_PORTS_LISTENER_ALLOC_ERROR,  // not enough memory to initialize listener
+};
+
+// Returns description of error code.
+const char *mg_get_error_string(mg_error error_code);
+
+// Retrieve detailed error code after some of mg_ functions fail.
+//
+// Resets last error code afterwards.
+// Only mg_start produces such errors at the moment.
+//
+// Return:
+//   If there was no error or function that failed doesn't support extended error reporting
+//   MG_ERROR_NONE is returned. Otherwise you get last error code.
+enum mg_error mg_get_last_error();
+
 // Prototype for the user-defined function. Mongoose calls this function
 // on every MG_* event.
 //