procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 09:23:24 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

libgimp, devel-docs: enhance GIMP-PLUGIN-DEBUG backtrace

Browse source
This commit is contained in:
bootchk 2020-11-21 14:08:36 -05:00 • committed by Jehan
parent c10ffd4f38
commit 59f2ba44c7
4 changed files with 531 additions and 224 deletions
Download patch file Download diff file Expand all files Collapse all files

287
devel-docs/debug-plug-ins.txt
View file

@ -2,74 +2,104 @@ Debugging Plug-ins
================== ==================
Eeek! The plug-in you're working on has a bug in it! And the fix isn't Eeek! The plug-in you're working on has a bug in it! And the fix isn't
completely obvious, so you want to use debugger to see what is going on. completely obvious, so you want to use a debugger to see what is going on.
But hmm, how does one start a plug-in under a debugger if GIMP is the one But hmm, how does one start a plug-in under a debugger if GIMP is the one
who is starting the plug-in... who is starting the plug-in...
To address this issue, libgimp has some hooks controlled by the To address this issue, libgimp has some hooks controlled by the
GIMP_PLUGIN_DEBUG environment variable. The idea is that you can attach GIMP_PLUGIN_DEBUG environment variable at runtime.
a debugger to the pid of the plug-in you want to debug. The format is as
follows:
GIMP_PLUGIN_DEBUG lets you arrange that a plug-in suspends when it starts,
and then you can start a debugger and attach the debugger to the pid of the
plug-in.
GIMP_PLUGIN_DEBUG also lets you arrange for log messages of levels WARNING,
CRITICAL, and ERROR (from the plug-in, GIMP libraries, and GLib libraries)
to be fatal and generate a backtrace at that point (also called
a stack trace, similar to that generated in a debugger using the 'bt' command.)
When GIMP_PLUGIN_DEBUG is not defined, depending on how other GLib environment
variables are defined, a plug-in may quietly execute past
warning and critical logged events, and only terminate on a ERROR logged event
(without a backtrace), or on a soft or hard fault such as a memory exception
(possibly producing a core dump that you can examine using a debugger.)
Format of GIMP_PLUGIN_DEBUG:
----------------------------
GIMP_PLUGIN_DEBUG=name<,options> GIMP_PLUGIN_DEBUG=name<,options>
"name" refers to the name of the plug-in binary that you wish to debug. "name" specifies the name of the plug-in that you wish to debug,
or "all" to debug every plug-in. See below "Plug-in names".
"options" is one or more of the following options, separated by :'s "options" is zero or more of the following options, separated by :'s
run: suspend the plug-in when its run_proc is called. run: suspend the plug-in when its run func is called.
query: suspend the plug-in when its query_proc is called. query: suspend the plug-in when its query func is called.
init: suspend the plug-in when its init_proc is called. init: suspend the plug-in when its init func is called.
pid: just print the pid of the plug-in on run_proc. quit: suspend the plug-in when its quit func is called.
fatal-warnings: emulate passing --g-fatal-warnings on the command line. pid: just print the pid of the plug-in on run_proc.
fw: shorthand for above. fatal-warnings: similar to "gimp --g-fatal-warnings" on the command line,
on: shorthand for run:fatal-warnings. This is also the default but for the plugin process
in the absence of an options string. fw: shorthand for above.
fatal-criticals: make CRITICAL level messages fatal (but not WARNING)
In the absence of an options string, only ERRORs are fatal and generate
a backtrace according to stack-trace-mode
The steps to debug a plug-in are as follows: To use a debugger on a C-language plug-in:
------------------------------
0. Make sure GIMP is built with debugging information (gcc -g) 0. Ensure GIMP was built with debugging information (gcc -g)
1. Start GIMP with the appropriate debugging environment variables 1. In a terminal, start GIMP with the environment variable GIMP_PLUGIN_DEBUG set
( e.g. ">GIMP_PLUGIN_DEBUG=blur,on gimp" )
2. Load the standalone plug-in program in the debugger (gdb or 2. In another terminal, start a debugger (gdb, lldb, or other) and load the plug-in
the ddd frontend to gdb) program into the debugger. Loading only loads the debug symbols.
( e.g. ">gdb blur" )
3. Invoke the plug-in procedure in GIMP. GIMP will start the plug-in 3. Invoke the plug-in procedure in GIMP. GIMP will start the plug-in
process, then send a STOP signal to it and then print a message with process, then suspend it and print the pid of the plug-in process
the pid of the plug-in process to the terminal. to the terminal where you started GIMP.
4. Attach to the pid of the plug-in process in the debugger 4. In the debugger, attach to the pid of the plug-in process.
(e.g. "gdb> attach <pid>")
5. Set breakpoints where you want the plug-in to stop in the debugger Expect the debugger to say where the plug-in is suspended.
6. Send the CONT signal (kill -CONT <pid>) to the plug-in process
(When compiled with Windows, resume the plug-in process with
gimp-debug-resume.exe <pid>)
7. Enter "continue" in the debugger. The plug-in will then continue
and break at the breakpoints.
Examples: 5. In the debugger, set breakpoints (or examine memory, or step, etc.)
6. Windows: resume the plug-in process with "gimp-debug-resume.exe <pid>"
(On Linux, the gdb continue command resumes the attached process.)
7. In the debugger, enter "continue". Expect the plug-in to resume under
control of the debugger and pause at breakpoints.
(e.g. "gdb> continue")
Examples using a debugger:
--------------------------
GIMP_PLUGIN_DEBUG=blur GIMP_PLUGIN_DEBUG=blur
When the blur plug-in is called to perform an action, it is suspended When the blur plug-in's run func is called (the run phase),
and the following is printed to the console: GIMP suspends it and prints to the console:
(blur:9000): LibGimp-DEBUG: Waiting for debugger... (blur:9000): LibGimp-DEBUG: Waiting for debugger...
9000 is the pid of the new plug-in process. You can start your debugger, 9000 is the pid of the new plug-in process. You can start your debugger,
attach to it, set breakpoints/watches/etc. and continue from there. attach to the plug-in, set breakpoints/watches/etc. and continue from there.
In case of the gdb typing "continue" will start the plugin. Using gdb command "continue" will resume the plugin.
Expect the plugin to execute until it hits a breakpoint or until a WARNING
or worse event is logged or until a hard fault such as a memory violation.
Then the debugger will be back in control.
GIMP_PLUGIN_DEBUG=blur,on GIMP_PLUGIN_DEBUG=blur,on
Same effect as above.
GIMP_PLUGIN_DEBUG=blur,run:fatal-warnings GIMP_PLUGIN_DEBUG=blur,run:fatal-warnings
Same effect as above. Same effect as above.
@ -80,20 +110,177 @@ GIMP_PLUGIN_DEBUG=blur,pid
(blur:9000): LibGimp-DEBUG: Here I am! (blur:9000): LibGimp-DEBUG: Here I am!
This simply prints the pid but doesn't halt the plug-in. It is simply This simply prints the pid but doesn't suspend the plug-in. It is a
convenience, since if your plug-in has a GUI, the GUI can start up convenience for a plug-in having a GUI. The GUI starts up and waits
and you can attach to it there while it is waiting for user input. for user input. When you attach, you will find the plug-in waiting
in the event loop.
GIMP_PLUGIN_DEBUG=blur,query GIMP_PLUGIN_DEBUG=blur,query
Same effect as if you did run, but instead suspends when the plug-in
is queried on GIMP startup.
GIMP_PLUGIN_DEBUG=blur,init GIMP_PLUGIN_DEBUG=blur,init
GIMP_PLUGIN_DEBUG=blur,quit
Same as above, but in the init phase of startup. Same effect as for "run", but instead libgimp suspends the plug-in before
one of a plugin's phases: query, init, run, quit
E.G. when it is queried or init'ed on GIMP startup.
To get a backtrace for a plug-in in any language:
-------------------------------------------------
0. Ensure GIMP (and all libraries you want details for)
were built with debugging information (gcc -g)
1. In a terminal, start GIMP with the environment variable GIMP_PLUGIN_DEBUG set
( e.g. ">GIMP_PLUGIN_DEBUG=all,fatal-criticals gimp" )
Expect GIMP to start normally.
2. In GIMP, do somthing that would invoke a plugin.
Whenever the specified plug-in processes generate log events of
the specified levels or worse, libgimp will print or offer to print
(depends on stack-trace-mode) a backtrace, and then terminate the plug-in.
The GIMP app will usually continue to run.
For interpreted language plug-ins, the backtrace will include many frames
from the interpreter and modules such as PyGObject. Exceptions in the
interpreted language may print on their own and not generate log events
to be caught by GIMP_PLUGIN_DEBUG. But log events from the interpreter
calling out (to LibGimp and GLib) can generate backtraces.
GIMP_PLUGIN_DEBUG and stack-trace-mode
--------------------------------------
GIMP_PLUGIN_DEBUG=all,fatal-warning only makes the machinery *consider*
generating a backtrace, for more log events. The 'stack-trace-mode' pertains.
The GIMP app on the command line takes a flag:
--stack-trace-mode [never, query, always]
When the GIMP app forks a plugin process, it passes that arg to the plugin,
and the arg controls how a backtrace is printed.
The default is "query", which means libgimp will ask you:
"[E]xit [S]tacktrace [P]roceed"
(similar to the GLib default handler for ERROR log events.)
"always" means libgimp prints a backtrace (and then the plugin terminates.)
"never" means libgimp does not print a backtrace, only a message. But for
GIMP_PLUGIN_DEBUG=all,fatal-warning, the plugin terminates on the first WARNING.
Examples getting a backtrace on logged events:
--------------------------------------------
GIMP_PLUGIN_DEBUG=blur,fatal-warnings
The blur plug-in will run until the first logged WARNING or worse,
from the plug-in, GIMP libraries, or GLib libraries.
Then a backtrace can print to the console and the blur plug-in terminate.
Usually you will also see a message from the main GIMP app
saying the plugin aborted without returning a value.
GIMP_PLUGIN_DEBUG=all,fatal-criticals
Every plug-in (whether you invoked it from the GIMP GUI or it was called
by another plug-in) will run until the first logged CRITICAL or worse,
from the plug-in, GIMP libraries, or GLib libraries.
Then, as above, a backtrace can print etc.
GIMP_PLUGIN_DEBUG=all
As above, for all plugins, but only for a logged ERROR.
Quality of a backtrace
----------------------
A detailed backtrace depends on:
1) building GIMP and dependencies with debug info enabled
2) having a debugger installed
When a debugger is not installed, a backtrace may lack details such as
function names and line numbers.
More about logging levels
-------------------------
See https://developer.gnome.org/glib/stable/glib-Message-Logging.html
Level Engendered by
-----------------------
WARNING g_warning().
CRITICAL g_return_value_if_fail() or g_return_if_fail().
ERROR g_assert() or g_error().
Use of logging levels is by convention, and libraries that GIMP uses may not
follow conventions.
Generally speaking...
WARNINGs are common but don't signify much. They might mean that your plug-in
code does not understand, or is sloppy with, the GIMP API.
CRITICALs are rare but more significant. They usually mean that GIMP will
attempt to continue past an errant condition. The GLib function
g_return_value_if_fail() is often used in GIMP code as a precondition,
required to succeed before a GIMP function executes its body,
the function returning early when the precondition fails.
ERRORs are usually dire. They always terminate a plug-in.
Plug-in names
-------------
A plug-in may register many PDB procedures. Use the plug-in name, not a
procedure-name, e.g. "file-psd" not "file-psd-save". When a plug-in is "run",
one of its PDB procedures is run, and all of its PDB procedures
are covered by a GIMP_PLUGIN_DEBUG definition.
A name is usually the name of the executable file, including any suffix.
Examples: "file-psd" or "foggify.py" or on some platforms "foo.exe."
Usually an interpreted plug-in has a hashbang on the first line
e.g. "#!/usr/bin/env python3" in the first line of foo.py.
Then the file is executable, GIMP forks that file, and the Linux loader
invokes the interpreter.
However, GIMP still allows a plug-in source
to lack a hashbang (and it is not technically "an executable")
but then GIMP forks the interpreter, passing the script filename.
In this case, you must still use the name of the script file e.g. "foo.py"
in GIMP_PLUGIN_DEBUG.
(Since forever, GIMP does not understand Python packages.
GIMP only installs Python plugins from directories named like foo/foo.py.
A directory that is a Python package (having an __init__.py file)
will be read by GIMP at startup, but GIMP will only install one plugin
from that directory, and only if the .py file is named like the directory.)
Finding plug-in source by name
------------------------------
A GIMP supported C language plug-in's source should be in a similar-named
directory in the GIMP repository. For example, "file-psd" is a directory
(but there is no "file-psd.c".)
An interpreted plug-in is *installed* in a directory of a similar name
e.g. "plug-ins/foggify/foggify.py".
But in the GIMP repository, foggify.py does not live at foggify/foggify.py
but at plug-ins/python/foggify.py .
Examples using other debug tools:
---------------------------------
Hmm, but what about memory debuggers such as valgrind or purify? For those Hmm, but what about memory debuggers such as valgrind or purify? For those
you can set the following: you can set the following:
@ -108,7 +295,11 @@ GIMP_PLUGIN_DEBUG_WRAPPER=debugger
put command line options here too, they will be parsed like they do put command line options here too, they will be parsed like they do
in the shell. in the shell.
When compiled with Windows, the plug-in process is halted by Windows functions.
Windows:
--------
When compiled with Windows, a plug-in process is halted by Windows functions.
It must be resumed externally by invoking gimp-debug-resume.exe <pid> It must be resumed externally by invoking gimp-debug-resume.exe <pid>
The plug-ins pid can be found out by invoking gimp-debug-resume.exe The plug-ins pid can be found out by invoking gimp-debug-resume.exe
without parameters. It shows the pid of all running processes. without parameters. It shows the pid of all running processes.

323
libgimp/gimp-debug.c
View file

@ -57,74 +57,164 @@
#include "gimp.h" #include "gimp.h"
#include "gimp-debug.h" #include "gimp-debug.h"
static GLogLevelFlags create_log_level_flags (void);
static void make_visible_libgimp_messages (void);
static void gimp_message_func (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer data);
static void gimp_fatal_func (const gchar *log_domain,
GLogLevelFlags flags,
const gchar *message,
gpointer data);
static const GDebugKey gimp_debug_keys[] = static const GDebugKey gimp_debug_keys[] =
{ {
{ "pid", GIMP_DEBUG_PID }, { "pid", GIMP_DEBUG_PID },
{ "fatal-warnings", GIMP_DEBUG_FATAL_WARNINGS }, { "fatal-warnings", GIMP_DEBUG_FATAL_WARNINGS },
{ "fatal-criticals", GIMP_DEBUG_FATAL_CRITICALS },
{ "fw", GIMP_DEBUG_FATAL_WARNINGS }, { "fw", GIMP_DEBUG_FATAL_WARNINGS },
{ "query", GIMP_DEBUG_QUERY }, { "query", GIMP_DEBUG_QUERY },
{ "init", GIMP_DEBUG_INIT }, { "init", GIMP_DEBUG_INIT },
{ "run", GIMP_DEBUG_RUN }, { "run", GIMP_DEBUG_RUN },
{ "quit", GIMP_DEBUG_QUIT }, { "quit", GIMP_DEBUG_QUIT }
{ "on", GIMP_DEBUG_DEFAULT }
}; };
static guint gimp_debug_flags = 0; /* Set by gimp_debug_configure() to partial parameterize gimp_fatal_handler(). */
static GimpStackTraceMode _stack_trace_mode = GIMP_STACK_TRACE_NEVER;
/* Set by _gimp_debug_init(). Exported by _gimp_get_debug_flags() */
static guint _gimp_debug_flags = 0;
/*
* Set _gimp_debug_flags, from env var GIMP_PLUGIN_DEBUG if it exists.
* Also ensure GLib default handler prints all log messages for domain LibGimp.
*/
void void
_gimp_debug_init (const gchar *basename) _gimp_debug_init (const gchar *basename)
{ {
const gchar *env_string = g_getenv ("GIMP_PLUGIN_DEBUG"); const gchar *env_string = g_getenv ("GIMP_PLUGIN_DEBUG");
const gchar *debug_options;
gint plugin_name_len;
gboolean is_debug_name_match_basename;
if (env_string) if (!env_string) return;
debug_options = strchr (env_string, ',');
/* Does name match basename or name match "all"
* Use strlen to allow basename to have prefix "all" without matching.
*/
/* Safe subtraction of pointers into the same string. */
plugin_name_len = debug_options - env_string;
is_debug_name_match_basename = (
((strlen (basename) == plugin_name_len) &&
(strncmp (basename, env_string, plugin_name_len) == 0)) ||
(strncmp (env_string, "all", plugin_name_len) == 0)
);
if (is_debug_name_match_basename && debug_options)
{ {
gchar *debug_string; _gimp_debug_flags =
const gchar *debug_messages; g_parse_debug_string (debug_options + 1,
gimp_debug_keys,
debug_string = strchr (env_string, ','); G_N_ELEMENTS (gimp_debug_keys));
if (debug_string)
{
gint len = debug_string - env_string;
if ((strlen (basename) == len) &&
(strncmp (basename, env_string, len) == 0))
{
gimp_debug_flags =
g_parse_debug_string (debug_string + 1,
gimp_debug_keys,
G_N_ELEMENTS (gimp_debug_keys));
}
}
else if (strcmp (env_string, basename) == 0)
{
gimp_debug_flags = GIMP_DEBUG_DEFAULT;
}
/* make debug output visible by setting G_MESSAGES_DEBUG */
debug_messages = g_getenv ("G_MESSAGES_DEBUG");
if (debug_messages)
{
gchar *tmp = g_strconcat (debug_messages, ",LibGimp", NULL);
g_setenv ("G_MESSAGES_DEBUG", tmp, TRUE);
g_free (tmp);
}
else
{
g_setenv ("G_MESSAGES_DEBUG", "LibGimp", TRUE);
}
} }
/* Else assert _gimp_debug_flags==0 .
* Only ERROR will be fatal, and fatal handler installed
* (to print according to stack-trace-mode)
*/
make_visible_libgimp_messages();
} }
guint guint
_gimp_debug_flags (void) _gimp_get_debug_flags (void)
{ {
return gimp_debug_flags; return _gimp_debug_flags;
} }
/*
* Configure GLib logging according to GIMP_PLUGIN_DEBUG
*/
void
_gimp_debug_configure (GimpStackTraceMode stack_trace_mode)
{
const gchar * const gimp_log_domains[] =
{
"LibGimp",
"LibGimpBase",
"LibGimpColor",
"LibGimpConfig",
"LibGimpMath",
"LibGimpModule",
"LibGimpThumb",
"LibGimpWidgets"
};
const gchar * const glib_log_domains[] =
{
"GLib",
"GLib-GObject",
"GLib-GIO",
};
gint i;
GLogLevelFlags fatal_mask;
_stack_trace_mode = stack_trace_mode;
/* Set handler for Gimp domains, for MESSAGE level.
* i.e. from g_message(), but not from g_info() (rarely used?).
*/
for (i = 0; i < G_N_ELEMENTS (gimp_log_domains); i++)
g_log_set_handler (gimp_log_domains[i],
G_LOG_LEVEL_MESSAGE,
gimp_message_func,
NULL);
/* Also set handler for "" i.e. app domain. */
g_log_set_handler (NULL,
G_LOG_LEVEL_MESSAGE,
gimp_message_func,
NULL);
/* Make fatal a subset of log levels (ERROR is always fatal)
* as specified by GIMP_PLUGIN_DEBUG now in _gimp_debug_flags
*/
fatal_mask = create_log_level_flags();
g_log_set_always_fatal (fatal_mask);
/* set our custom handler for fatal messages, for many domains. */
/* For the null i.e. "" i.e. app i.e. plugin domain */
g_log_set_handler (NULL,
fatal_mask,
gimp_fatal_func,
NULL);
for (i = 0; i < G_N_ELEMENTS (gimp_log_domains); i++)
g_log_set_handler (gimp_log_domains[i],
fatal_mask,
gimp_fatal_func,
NULL);
for (i = 0; i < G_N_ELEMENTS (glib_log_domains); i++)
g_log_set_handler (glib_log_domains[i],
fatal_mask,
gimp_fatal_func,
NULL);
}
/*
* Suspend i.e. pause the plugin process.
*/
void void
_gimp_debug_stop (void) _gimp_debug_stop (void)
{ {
@ -176,3 +266,152 @@ _gimp_debug_stop (void)
#endif #endif
} }
/* private functions */
/*
* Append domain LibGimp to env var G_MESSAGES_DEBUG.
* Per GLib docs, that makes default handler print all levels of log messages,
* from domain LibGimp.
* We may yet install non-default handler gimp_fatal_func(), for some levels,
* which prints the message and also may generate stack trace.
*
* This does not depend on GIMP_PLUGIN_DEBUG or any plugin names therein.
* This does not affect the Gimp app, whose environment is distinct.
* This does not make a plugin's own logged messages visible,
* since the plugin is in a distinct domain.
*/
static void
make_visible_libgimp_messages (void)
{
const gchar *debug_messages = g_getenv ("G_MESSAGES_DEBUG");
if (debug_messages)
{
gchar *tmp = g_strconcat (debug_messages, ",LibGimp", NULL);
g_setenv ("G_MESSAGES_DEBUG", tmp, TRUE);
g_free (tmp);
}
else
{
g_setenv ("G_MESSAGES_DEBUG", "LibGimp", TRUE);
}
}
/* Create GLogLevelFlags for fatal,
* from current fatal flags and from GIMP_PLUGIN_DEBUG env var.
*/
static GLogLevelFlags
create_log_level_flags(void)
{
GLogLevelFlags result;
result = g_log_set_always_fatal (G_LOG_FATAL_MASK);
/* result is the old one, and may have flags set already
* via the GLib G_DEBUG environment variable.
*/
/* Ensure ERROR remains fatal.
* Even if GIMP_PLUGIN_DEBUG is not defined, or defined "=run"
* we install fatal handler for ERROR for all plugins.
*/
result |= G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
if (_gimp_debug_flags & GIMP_DEBUG_FATAL_WARNINGS)
result |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
if (_gimp_debug_flags & GIMP_DEBUG_FATAL_CRITICALS)
result |= G_LOG_LEVEL_CRITICAL;
return result;
}
/*
* Handler for GLib log events of MESSAGE level.
* Signature is GLogFunc
*/
static void
gimp_message_func (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer data)
{
gimp_message (message);
}
/*
* Handler for fatal GLib logging events.
* Signature is GLogFunc
*/
static void
gimp_fatal_func (const gchar *log_domain,
GLogLevelFlags flags,
const gchar *message,
gpointer data)
{
const gchar *level;
switch (flags & G_LOG_LEVEL_MASK)
{
case G_LOG_LEVEL_WARNING:
level = "WARNING";
break;
case G_LOG_LEVEL_CRITICAL:
level = "CRITICAL";
break;
case G_LOG_LEVEL_ERROR:
level = "ERROR";
break;
default:
level = "FATAL";
break;
}
/* Earlier, gimp.c g_set_prgname to short basename; progname is full path. */
/*
* Print message canonical to what GLib's default handler would.
* Except prefix with which plugin using short name i.e. basename
* so reader can distinguish interleaved messages from plugin or app process.
* The log_domain is which library logged the event.
*/
g_printerr ("Plugin %s: %s: %s: %s\n",
g_get_prgname(), log_domain, level, message);
#ifndef G_OS_WIN32
switch (_stack_trace_mode)
{
case GIMP_STACK_TRACE_NEVER:
break;
case GIMP_STACK_TRACE_QUERY:
{
sigset_t sigset;
sigemptyset (&sigset);
sigprocmask (SIG_SETMASK, &sigset, NULL);
gimp_stack_trace_query (log_domain);
}
break;
case GIMP_STACK_TRACE_ALWAYS:
{
sigset_t sigset;
sigemptyset (&sigset);
sigprocmask (SIG_SETMASK, &sigset, NULL);
gimp_stack_trace_print (log_domain, stdout, NULL);
}
break;
}
#endif /* ! G_OS_WIN32 */
/* Do not end with gimp_quit().
* We want the plug-in to continue its normal crash course, otherwise
* we won't get the "Plug-in crashed" error in GIMP.
*/
exit (EXIT_FAILURE);
}

6
libgimp/gimp-debug.h
View file

@ -32,14 +32,14 @@ typedef enum
GIMP_DEBUG_INIT = 1 << 3, GIMP_DEBUG_INIT = 1 << 3,
GIMP_DEBUG_RUN = 1 << 4, GIMP_DEBUG_RUN = 1 << 4,
GIMP_DEBUG_QUIT = 1 << 5, GIMP_DEBUG_QUIT = 1 << 5,
GIMP_DEBUG_FATAL_CRITICALS = 1 << 6,
GIMP_DEBUG_DEFAULT = (GIMP_DEBUG_RUN | GIMP_DEBUG_FATAL_WARNINGS)
} GimpDebugFlag; } GimpDebugFlag;
void _gimp_debug_init (const gchar *basename); void _gimp_debug_init (const gchar *basename);
void _gimp_debug_configure (GimpStackTraceMode stack_trace_mode);
guint _gimp_debug_flags (void); guint _gimp_get_debug_flags (void);
void _gimp_debug_stop (void); void _gimp_debug_stop (void);

137
libgimp/gimp.c
View file

@ -108,14 +108,6 @@
static void gimp_close (void); static void gimp_close (void);
static void gimp_message_func (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer data);
static void gimp_fatal_func (const gchar *log_domain,
GLogLevelFlags flags,
const gchar *message,
gpointer data);
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
@ -506,54 +498,7 @@ gimp_main (GType plug_in_type,
bind_textdomain_codeset (GETTEXT_PACKAGE"-libgimp", "UTF-8"); bind_textdomain_codeset (GETTEXT_PACKAGE"-libgimp", "UTF-8");
#endif #endif
/* set handler both for the "LibGimp" and "" domains */ _gimp_debug_configure (stack_trace_mode);
{
const gchar * const log_domains[] =
{
"LibGimp",
"LibGimpBase",
"LibGimpColor",
"LibGimpConfig",
"LibGimpMath",
"LibGimpModule",
"LibGimpThumb",
"LibGimpWidgets"
};
gint i;
for (i = 0; i < G_N_ELEMENTS (log_domains); i++)
g_log_set_handler (log_domains[i],
G_LOG_LEVEL_MESSAGE,
gimp_message_func,
NULL);
g_log_set_handler (NULL,
G_LOG_LEVEL_MESSAGE,
gimp_message_func,
NULL);
}
if (_gimp_debug_flags () & GIMP_DEBUG_FATAL_WARNINGS)
{
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
g_log_set_handler (NULL,
G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL,
gimp_fatal_func,
NULL);
}
else
{
g_log_set_handler (NULL,
G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL,
gimp_fatal_func,
NULL);
}
PLUG_IN = g_object_new (plug_in_type, PLUG_IN = g_object_new (plug_in_type,
"read-channel", read_channel, "read-channel", read_channel,
@ -564,7 +509,7 @@ gimp_main (GType plug_in_type,
if (strcmp (argv[ARG_MODE], "-query") == 0) if (strcmp (argv[ARG_MODE], "-query") == 0)
{ {
if (_gimp_debug_flags () & GIMP_DEBUG_QUERY) if (_gimp_get_debug_flags () & GIMP_DEBUG_QUERY)
_gimp_debug_stop (); _gimp_debug_stop ();
_gimp_plug_in_query (PLUG_IN); _gimp_plug_in_query (PLUG_IN);
@ -576,7 +521,7 @@ gimp_main (GType plug_in_type,
if (strcmp (argv[ARG_MODE], "-init") == 0) if (strcmp (argv[ARG_MODE], "-init") == 0)
{ {
if (_gimp_debug_flags () & GIMP_DEBUG_INIT) if (_gimp_get_debug_flags () & GIMP_DEBUG_INIT)
_gimp_debug_stop (); _gimp_debug_stop ();
_gimp_plug_in_init (PLUG_IN); _gimp_plug_in_init (PLUG_IN);
@ -586,9 +531,9 @@ gimp_main (GType plug_in_type,
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
if (_gimp_debug_flags () & GIMP_DEBUG_RUN) if (_gimp_get_debug_flags () & GIMP_DEBUG_RUN)
_gimp_debug_stop (); _gimp_debug_stop ();
else if (_gimp_debug_flags () & GIMP_DEBUG_PID) else if (_gimp_get_debug_flags () & GIMP_DEBUG_PID)
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Here I am!"); g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Here I am!");
_gimp_plug_in_run (PLUG_IN); _gimp_plug_in_run (PLUG_IN);
@ -953,7 +898,7 @@ gimp_get_progname (void)
static void static void
gimp_close (void) gimp_close (void)
{ {
if (_gimp_debug_flags () & GIMP_DEBUG_QUIT) if (_gimp_get_debug_flags () & GIMP_DEBUG_QUIT)
_gimp_debug_stop (); _gimp_debug_stop ();
_gimp_plug_in_quit (PLUG_IN); _gimp_plug_in_quit (PLUG_IN);
@ -966,76 +911,8 @@ gimp_close (void)
g_clear_object (&PLUG_IN); g_clear_object (&PLUG_IN);
} }
static void
gimp_message_func (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer data)
{
gimp_message (message);
}
static void
gimp_fatal_func (const gchar *log_domain,
GLogLevelFlags flags,
const gchar *message,
gpointer data)
{
const gchar *level;
switch (flags & G_LOG_LEVEL_MASK)
{
case G_LOG_LEVEL_WARNING:
level = "WARNING";
break;
case G_LOG_LEVEL_CRITICAL:
level = "CRITICAL";
break;
case G_LOG_LEVEL_ERROR:
level = "ERROR";
break;
default:
level = "FATAL";
break;
}
g_printerr ("%s: %s: %s\n",
progname, level, message);
#ifndef G_OS_WIN32
switch (stack_trace_mode)
{
case GIMP_STACK_TRACE_NEVER:
break;
case GIMP_STACK_TRACE_QUERY:
{
sigset_t sigset;
sigemptyset (&sigset);
sigprocmask (SIG_SETMASK, &sigset, NULL);
gimp_stack_trace_query (progname);
}
break;
case GIMP_STACK_TRACE_ALWAYS:
{
sigset_t sigset;
sigemptyset (&sigset);
sigprocmask (SIG_SETMASK, &sigset, NULL);
gimp_stack_trace_print (progname, stdout, NULL);
}
break;
}
#endif /* ! G_OS_WIN32 */
/* Do not end with gimp_quit().
* We want the plug-in to continue its normal crash course, otherwise
* we won't get the "Plug-in crashed" error in GIMP.
*/
exit (EXIT_FAILURE);
}
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
@ -1043,7 +920,7 @@ gimp_fatal_func (const gchar *log_domain,
static LONG WINAPI static LONG WINAPI
gimp_plugin_sigfatal_handler (PEXCEPTION_POINTERS pExceptionInfo) gimp_plugin_sigfatal_handler (PEXCEPTION_POINTERS pExceptionInfo)
{ {
g_printerr ("%s: fatal error\n", progname); g_printerr ("Plugin signal handler: %s: fatal error\n", progname);
SetUnhandledExceptionFilter (_prevExceptionFilter); SetUnhandledExceptionFilter (_prevExceptionFilter);