#define BT_BUF_SIZE 100
#endif /* HAVE_BACKTRACE */
+#ifdef HAVE_DBGHELP
+#include <Windows.h>
+#include <dbghelp.h>
+#include <tlhelp32.h>
+#endif /* HAVE_DBGHELP */
+
+#ifdef G_OS_WIN32
+/* We take a lock in order to
+ * 1) keep colors and content together for a single line
+ * 2) serialise gst_print*() and gst_printerr*() with each other and the debug
+ * log to keep the debug log colouring from interfering with those and
+ * to prevent broken output on the windows terminal.
+ * Maybe there is a better way but for now this will do the right
+ * thing. */
+G_LOCK_DEFINE_STATIC (win_print_mutex);
+#endif
+
extern gboolean gst_is_initialized (void);
/* we want these symbols exported even if debug is disabled, to maintain
GST_CAT_ELEMENT_PADS = _gst_debug_category_new ("GST_ELEMENT_PADS",
GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
GST_CAT_PADS = _gst_debug_category_new ("GST_PADS",
- GST_DEBUG_BOLD | GST_DEBUG_FG_RED | GST_DEBUG_BG_RED, NULL);
+ GST_DEBUG_BOLD | GST_DEBUG_FG_RED | GST_DEBUG_BG_BLUE, NULL);
GST_CAT_PERFORMANCE = _gst_debug_category_new ("GST_PERFORMANCE",
GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
GST_CAT_PIPELINE = _gst_debug_category_new ("GST_PIPELINE",
GstClockTime elapsed;
gchar *obj = NULL;
GstDebugColorMode color_mode;
+ const gchar *message_str;
FILE *log_file = user_data ? user_data : stderr;
gchar c;
+ /* Get message string first because printing it might call into our custom
+ * printf format extension mechanism which in turn might log something, e.g.
+ * from inside gst_structure_to_string() when something can't be serialised.
+ * This means we either need to do this outside of any critical section or
+ * use a recursive lock instead. As we always need the message string in all
+ * code paths, we might just as well get it here first thing and outside of
+ * the win_print_mutex critical section. */
+ message_str = gst_debug_message_get (message);
+
/* __FILE__ might be a file name or an absolute path or a
* relative path, irrespective of the exact compiler used,
* in which case we want to shorten it to the filename for
if (color_mode != GST_DEBUG_COLOR_MODE_OFF) {
#ifdef G_OS_WIN32
- /* We take a lock to keep colors and content together.
- * Maybe there is a better way but for now this will do the right
- * thing. */
- static GMutex win_print_mutex;
- g_mutex_lock (&win_print_mutex);
+ G_LOCK (win_print_mutex);
if (color_mode == GST_DEBUG_COLOR_MODE_UNIX) {
#endif
/* colors, non-windows */
pidcolor, pid, clear, g_thread_self (), levelcolor,
gst_debug_level_get_name (level), clear, color,
gst_debug_category_get_name (category), file, line, function, obj,
- clear, gst_debug_message_get (message));
+ clear, message_str);
fflush (log_file);
#undef PRINT_FMT
g_free (color);
fflush (log_file);
/* message */
SET_COLOR (clear);
- fprintf (log_file, " %s\n", gst_debug_message_get (message));
+ fprintf (log_file, " %s\n", message_str);
fflush (log_file);
}
- g_mutex_unlock (&win_print_mutex);
+ G_UNLOCK (win_print_mutex);
#endif
} else {
/* no color, all platforms */
fprintf (log_file, "%" GST_TIME_FORMAT PRINT_FMT, GST_TIME_ARGS (elapsed),
pid, g_thread_self (), gst_debug_level_get_name (level),
gst_debug_category_get_name (category), file, line, function, obj,
- gst_debug_message_get (message));
+ message_str);
fflush (log_file);
#undef PRINT_FMT
}
* the name */
#ifdef HAVE_DLADDR
if (dladdr ((gpointer) func, &dl_info) && dl_info.dli_sname) {
- gchar *name = g_strdup (dl_info.dli_sname);
+ const gchar *name = g_intern_string (dl_info.dli_sname);
_gst_debug_register_funcptr (func, name);
return name;
#endif
{
gchar *name = g_strdup_printf ("%p", (gpointer) func);
+ const gchar *iname = g_intern_string (name);
- _gst_debug_register_funcptr (func, name);
- return name;
+ g_free (name);
+
+ _gst_debug_register_funcptr (func, iname);
+ return iname;
}
}
if (!__gst_function_pointers)
__gst_function_pointers = g_hash_table_new (g_direct_hash, g_direct_equal);
- if (!g_hash_table_lookup (__gst_function_pointers, ptr))
+ if (!g_hash_table_lookup (__gst_function_pointers, ptr)) {
g_hash_table_insert (__gst_function_pointers, ptr, (gpointer) ptrname);
+ }
+
+ g_mutex_unlock (&__dbg_functions_mutex);
+}
+
+void
+_priv_gst_debug_cleanup (void)
+{
+ g_mutex_lock (&__dbg_functions_mutex);
+
+ if (__gst_function_pointers) {
+ g_hash_table_unref (__gst_function_pointers);
+ __gst_function_pointers = NULL;
+ }
g_mutex_unlock (&__dbg_functions_mutex);
}
}
void
+_priv_gst_debug_cleanup (void)
+{
+}
+
+void
gst_debug_log (GstDebugCategory * category, GstDebugLevel level,
const gchar * file, const gchar * function, gint line,
GObject * object, const gchar * format, ...)
str = gst_info_strdup_vprintf (format, args);
va_end (args);
+#ifdef G_OS_WIN32
+ G_LOCK (win_print_mutex);
+#endif
+
g_print ("%s", str);
+
+#ifdef G_OS_WIN32
+ G_UNLOCK (win_print_mutex);
+#endif
g_free (str);
}
str = gst_info_strdup_vprintf (format, args);
va_end (args);
+#ifdef G_OS_WIN32
+ G_LOCK (win_print_mutex);
+#endif
+
g_print ("%s\n", str);
+
+#ifdef G_OS_WIN32
+ G_UNLOCK (win_print_mutex);
+#endif
g_free (str);
}
str = gst_info_strdup_vprintf (format, args);
va_end (args);
+#ifdef G_OS_WIN32
+ G_LOCK (win_print_mutex);
+#endif
+
g_printerr ("%s", str);
+
+#ifdef G_OS_WIN32
+ G_UNLOCK (win_print_mutex);
+#endif
g_free (str);
}
str = gst_info_strdup_vprintf (format, args);
va_end (args);
+#ifdef G_OS_WIN32
+ G_LOCK (win_print_mutex);
+#endif
+
g_printerr ("%s\n", str);
+
+#ifdef G_OS_WIN32
+ G_UNLOCK (win_print_mutex);
+#endif
g_free (str);
}
#define generate_backtrace_trace() NULL
#endif /* HAVE_BACKTRACE */
+#ifdef HAVE_DBGHELP
+static void
+dbghelp_initialize_symbols (HANDLE process)
+{
+ static gsize initialization_value = 0;
+
+ if (g_once_init_enter (&initialization_value)) {
+ GST_INFO ("Initializing Windows symbol handler");
+ SymSetOptions (SYMOPT_LOAD_LINES);
+ SymInitialize (process, NULL, TRUE);
+ GST_INFO ("Initialized Windows symbol handler");
+
+ g_once_init_leave (&initialization_value, 1);
+ }
+}
+
+static gchar *
+generate_dbghelp_trace (void)
+{
+ HANDLE process = GetCurrentProcess ();
+ HANDLE thread = GetCurrentThread ();
+ IMAGEHLP_MODULE64 module_info;
+ DWORD machine;
+ CONTEXT context;
+ STACKFRAME64 frame = { 0 };
+ PVOID save_context;
+ GString *trace = g_string_new (NULL);
+
+ dbghelp_initialize_symbols (process);
+
+ memset (&context, 0, sizeof (CONTEXT));
+ context.ContextFlags = CONTEXT_FULL;
+
+ RtlCaptureContext (&context);
+
+ frame.AddrPC.Mode = AddrModeFlat;
+ frame.AddrStack.Mode = AddrModeFlat;
+ frame.AddrFrame.Mode = AddrModeFlat;
+
+#if (defined _M_IX86)
+ machine = IMAGE_FILE_MACHINE_I386;
+ frame.AddrFrame.Offset = context.Ebp;
+ frame.AddrPC.Offset = context.Eip;
+ frame.AddrStack.Offset = context.Esp;
+#elif (defined _M_X64)
+ machine = IMAGE_FILE_MACHINE_AMD64;
+ frame.AddrFrame.Offset = context.Rbp;
+ frame.AddrPC.Offset = context.Rip;
+ frame.AddrStack.Offset = context.Rsp;
+#else
+ goto done;
+#endif
+
+ module_info.SizeOfStruct = sizeof (module_info);
+ save_context = (machine == IMAGE_FILE_MACHINE_I386) ? NULL : &context;
+
+ while (TRUE) {
+ char buffer[sizeof (SYMBOL_INFO) + MAX_SYM_NAME * sizeof (TCHAR)];
+ PSYMBOL_INFO symbol = (PSYMBOL_INFO) buffer;
+ IMAGEHLP_LINE64 line;
+ DWORD displacement = 0;
+
+ symbol->SizeOfStruct = sizeof (SYMBOL_INFO);
+ symbol->MaxNameLen = MAX_SYM_NAME;
+
+ line.SizeOfStruct = sizeof (line);
+
+ if (!StackWalk64 (machine, process, thread, &frame, save_context, 0,
+ SymFunctionTableAccess64, SymGetModuleBase64, 0))
+ break;
+
+ if (SymFromAddr (process, frame.AddrPC.Offset, 0, symbol))
+ g_string_append_printf (trace, "%s ", symbol->Name);
+ else
+ g_string_append (trace, "?? ");
+
+ if (SymGetLineFromAddr64 (process, frame.AddrPC.Offset, &displacement,
+ &line))
+ g_string_append_printf (trace, "(%s:%u)", line.FileName, line.LineNumber);
+ else if (SymGetModuleInfo64 (process, frame.AddrPC.Offset, &module_info))
+ g_string_append_printf (trace, "(%s)", module_info.ImageName);
+ else
+ g_string_append_printf (trace, "(%s)", "??");
+
+ g_string_append (trace, "\n");
+ }
+
+done:
+ return g_string_free (trace, FALSE);
+}
+#endif /* HAVE_DBGHELP */
+
/**
* gst_debug_get_stack_trace:
* @flags: A set of #GstStackTraceFlags to determine how the stack
trace = generate_unwind_trace (flags);
#endif /* HAVE_UNWIND */
+#ifdef HAVE_DBGHELP
+ trace = generate_dbghelp_trace ();
+#endif
+
if (trace)
return trace;
else if (have_backtrace)
/**
* gst_debug_print_stack_trace:
*
- * If libunwind or glibc backtrace are present
+ * If libunwind, glibc backtrace or DbgHelp are present
* a stack trace is printed.
*/
void
{
gchar *trace = gst_debug_get_stack_trace (GST_STACK_TRACE_SHOW_FULL);
- if (trace)
+ if (trace) {
+#ifdef G_OS_WIN32
+ G_LOCK (win_print_mutex);
+#endif
+
g_print ("%s\n", trace);
+#ifdef G_OS_WIN32
+ G_UNLOCK (win_print_mutex);
+#endif
+ }
+
g_free (trace);
}
gint64 now = g_get_monotonic_time ();
const gchar *message_str = gst_debug_message_get (message);
+ /* __FILE__ might be a file name or an absolute path or a
+ * relative path, irrespective of the exact compiler used,
+ * in which case we want to shorten it to the filename for
+ * readability. */
+ c = file[0];
+ if (c == '.' || c == '/' || c == '\\' || (c != '\0' && file[1] == ':')) {
+ file = gst_path_basename (file);
+ }
+
+ if (object) {
+ obj = gst_debug_print_object (object);
+ } else {
+ obj = (gchar *) "";
+ }
+
+ elapsed = GST_CLOCK_DIFF (_priv_gst_start_time, gst_util_get_timestamp ());
+ pid = getpid ();
+ thread = g_thread_self ();
+
+ /* no color, all platforms */
+#define PRINT_FMT " "PID_FMT" "PTR_FMT" %s "CAT_FMT" %s\n"
+ output =
+ g_strdup_printf ("%" GST_TIME_FORMAT PRINT_FMT, GST_TIME_ARGS (elapsed),
+ pid, thread, gst_debug_level_get_name (level),
+ gst_debug_category_get_name (category), file, line, function, obj,
+ message_str);
+#undef PRINT_FMT
+
+ output_len = strlen (output);
+
+ if (object != NULL)
+ g_free (obj);
+
G_LOCK (ring_buffer_logger);
if (logger->thread_timeout > 0) {
+ gchar *buf;
+
/* Remove all threads that saw no output since thread_timeout seconds.
* By construction these are all at the tail of the queue, and the queue
* is ordered by last use, so we just need to look at the tail.
break;
g_hash_table_remove (logger->thread_index, log->thread);
- while ((output = g_queue_pop_head (&log->log)))
- g_free (output);
+ while ((buf = g_queue_pop_head (&log->log)))
+ g_free (buf);
g_free (log);
g_queue_pop_tail (&logger->threads);
}
/* Get logger for this thread, and put it back at the
* head of the threads queue */
- thread = g_thread_self ();
log = g_hash_table_lookup (logger->thread_index, thread);
if (!log) {
log = g_new0 (GstRingBufferLog, 1);
}
log->last_use = now;
- /* __FILE__ might be a file name or an absolute path or a
- * relative path, irrespective of the exact compiler used,
- * in which case we want to shorten it to the filename for
- * readability. */
- c = file[0];
- if (c == '.' || c == '/' || c == '\\' || (c != '\0' && file[1] == ':')) {
- file = gst_path_basename (file);
- }
-
- pid = getpid ();
-
- if (object) {
- obj = gst_debug_print_object (object);
- } else {
- obj = (gchar *) "";
- }
-
- elapsed = GST_CLOCK_DIFF (_priv_gst_start_time, gst_util_get_timestamp ());
-
- /* no color, all platforms */
-#define PRINT_FMT " "PID_FMT" "PTR_FMT" %s "CAT_FMT" %s\n"
- output =
- g_strdup_printf ("%" GST_TIME_FORMAT PRINT_FMT, GST_TIME_ARGS (elapsed),
- pid, thread, gst_debug_level_get_name (level),
- gst_debug_category_get_name (category), file, line, function, obj,
- message_str);
-#undef PRINT_FMT
-
- output_len = strlen (output);
-
if (output_len < logger->max_size_per_thread) {
gchar *buf;
log->log_size = 0;
}
- if (object != NULL)
- g_free (obj);
-
G_UNLOCK (ring_buffer_logger);
}
projects / platform / upstream / gstreamer.git / blobdiff