                              Wine Documentation                               
Prev                                                                       Next
-------------------------------------------------------------------------------

Chapter 2. Debugging Wine

2.1. Introduction

Written by Eric Pouech <Eric.Pouech@wanadoo.fr> (Last updated: 6/14/2000)

(Extracted from wine/documentation/winedbg)

2.1.1. Processes and threads: in underlying OS and in Windows

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).

2.1.2. Wine, debugging and WineDbg

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, not
the one in IMAGEHLP.DLL), and allows any program (emulated or Winelib) using
that API to debug a W-process.

WineDbg is a Winelib application making use of this API to allow debugging both
any Wine or Winelib applications as well as Wine itself (kernel and all DLLs).

-------------------------------------------------------------------------------
Prev                                 Home                                  Next
Compiling Wine                        Up                     WineDbg's modes of
                                                                     invocation
