Before going into the depths of debugging in Wine, here's a small overview of process and thread handling in Wine. It has to be clear that there are two different beasts: processes/threads from the Unix point of view and processes/threads from a Windows point of view.
Each Windows' thread is implemented as a Unix process (under
Linux using the clone
syscall), meaning
that all threads of a same Windows' process share the same
(unix) address space.
In the following:
W-process
means a process in Windows' terminology
U-process
means a process in Unix' terminology
W-thread
means a thread in Windows' terminology
A W-process
is made of one or several
W-threads
. Each
W-thread
is mapped to one and only one
U-process
. All
U-processes
of a same
W-process
share the same address space.
Each Unix process can be identified by two values:
the Unix process id (upid
in the following)
the Windows's thread id (tid
)
Each Windows' process has also a Windows' process id
(wpid
in the following). It must be clear
that upid
and wpid
are
different and shall not be used instead of the other.
Wpid
and tid
are
defined (Windows) system wide. They must not be confused
with process or thread handles which, as any handle, is an
indirection to a system object (in this case process or
thread). A same process can have several different handles
on the same kernel object. The handles can be defined as
local (the values is only valid in a process), or system
wide (the same handle can be used by any
W-process
).
When talking of debugging in Wine, there are at least two levels to think of:
the Windows' debugging API.
the Wine integrated debugger, dubbed winedbg.
Wine implements most of the Windows' debugging API (the
part in KERNEL32.DLL, not the one in
IMAGEHLP.DLL), and allows any program
(emulated or Winelib) using that API to debug a
W-process
.
Wine also implements DBGHELP.DLL which allows to look into symbols and types from any module (if the module has been compiled with the proper options).
winedbg is a Winelib application making use of these APIs (KERNEL32.DLL's debugging API and DBGHELP.DLL) to allow debugging both any Wine or Winelib applications as well as Wine itself (kernel and all DLLs).