JPH06161817A - Thread online debug device - Google Patents

Abstract

(57) [Abstract] [Purpose] To realize a thread online debug device that can online debug some threads while operating multiple threads. [Configuration] Assembler level remote debug monitor having execution control and data access functions depending on target microprocessor unit such as single step and breakpoint, and remote source used by connecting to the remote debug monitor by communication An online debug device equipped with a code debugger, wherein the remote debug monitor operates as a thread in the debugged process, and at the same time is treated as a process independent of the debugged process. To receive via an asynchronous signal handler.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugging device,
More specifically, the present invention relates to a debug device that enables individual threads, which are units that can be executed in parallel in a UNIX (registered trademark) user process, to be individually debugged while the user process is operating.

[0002]

2. Description of the Related Art In UNIX, there is a process debugger called sdb, which is realized by the following method. 8 is a diagram showing a debug mode of sdb, and FIG. 9 is a diagram (program list) showing a flow of basic processing of sdb.

Activation of child process sdb uses the fork command to generate the process to be debugged as a child process. At this time, sdb becomes the parent process. Then, control is temporarily transferred to the temporary code of the child process (the child process does not exist yet), and ptrace (0,0,0,0) is executed to inform UNIX that it is the debug target. UNIX sets a trace flag in the management table of the process to be debugged. Finally, the substance of the debugged process is loaded (exec command execution), and sd is restarted.
Control is transferred to b. The sdb waits for the child process (wait) to be released and waits for the user's command (read).

Execution control of child process and data access Commands for execution control of child process and data access are all executed by breaking down the ptrace system call of UNIX. Breakpoints are also realized by using ptrace to write an illegal processor instruction or a break instruction into the logical space of the child process. Then, the child process is activated by the execution command, and sdb waits for a hit at the breakpoint (wait).

Breakpoint hit notification Breakpoint hits are sent to the parent process, sdb.
Will be notified. Debugger waiting was wakeup
Then, the breakpoint is released and the command input is waited again.

[0006]

By the way, in the UNIX process debugger, the process to be debugged stops due to a breakpoint hit. Therefore, a plurality of threads, which are units that can be concurrently executed in the process to be debugged, are operated. However, there is a problem that it is impossible to debug some threads online. To make this possible, it is necessary to solve the following problems.

(1) Thread Debugger Configuration The command processing part related to execution control such as breakpoints, single step and continuous execution in the function of sdb basically needs to be present in the process to be debugged. (2) Thread debug function To enable online debugging of user threads, debug functions such as breakpoint set and single step, and UNIX thread management such as continuous execution, stop, asynchronous reception of messages (handled as commands), etc. Function is required. However, when using the process debug function of UNIX, it is necessary to devise to stop only the relevant thread without stopping the entire process due to a break hit or a single step. (3) Asynchronous command processing method The debugged process must be able to continue execution without stopping, regardless of the wait for the debug command reception of the thread monitor inside the process.

SUMMARY OF THE INVENTION An object of the present invention is to solve the above problems and to provide a thread online debug device capable of online debugging a part of threads while operating a plurality of threads.

[0009]

In order to achieve such an object, according to the present invention, an assembler level remote debug having execution control and data access functions depending on a target microprocessor unit such as a single step or a breakpoint is provided. An online debug device comprising a monitor and a remote source code debugger used in communication with the remote debug monitor, the remote debug monitor operating as a thread in the debugged process at the same time. It is treated as a process independent of the debugged process, and is characterized in that it receives an illegal instruction signal of a breakpoint hit via an asynchronous signal handler.

[0010]

The C language source code debugger is roughly divided into a command processing section, a source code display section and a symbol operating section (rSDB), and an execution control section and a memory access section (rDBM). The rSDB always operates on the workstation and is used by connecting to the rDBM for communication. The rDBM operates as a thread in the debugged process and is treated as a process independent of the debugged process. The illegal instruction signal handler of the debugged process directly receives the illegal instruction signal of the breakpoint hit, and r
The DBM is notified. It is the same as sdb that the illegal instruction of the host machine and the illegal instruction signal of UNIX are used to realize the thread break function, but the illegal instruction signal of the breakpoint hit is received from UNIX instead of rSDB. Is different from the conventional one in that the rDBM is received via an asynchronous signal handler.

[0011]

The present invention will be described in detail below with reference to the drawings.
First, a simulation development environment to which the present invention is applied will be described. In the simulation development environment shown in FIG. 1, reference numeral 10 denotes a system process, which is a process simulating a target software system and is composed of an asynchronous signal handler 20, a remote debug monitor (hereinafter abbreviated as rDBM) 11, and a thread 12. ing.

Reference numeral 30 is a remote source code which controls and controls the source code and symbols and can be used simultaneously.
Debugger (hereinafter abbreviated as rSDB), rDBM11
Can be used as a C language level debugger. By preparing a plurality of rSDBs, various debug modes can be effectively dealt with. Reference numeral 40 denotes a UNIX OS, which gives necessary signals to the signal handler 20.

FIG. 2 is a conceptual block diagram of a C language source code debugger used in the system process shown in FIG. A general C language source code debugger is basically composed of a command processing unit, a source code display unit, a symbol operation unit, an execution control unit, and a memory access unit. In particular, the symbol operation unit depends on the object format, and the execution control unit depends on a microprocessor unit (hereinafter abbreviated as MPU) such as a single step or a breakpoint. In the present invention, these are separated into two independent functions for generalization.

In FIG. 2, reference numeral 100 denotes a C language level debugger, which has a C language level debug support environment 110 having functions such as command processing, source code display and symbol manipulation, and functions such as command execution control and memory access. The assembler debugger 120 is included.
Both are independently separated, and signals can be transmitted and received by communication. The symbol P in the figure indicates that the process (for example, rSDB) is a UNIX process, and the symbol P / T indicates that the process is a UNIX process or a real-time task.

The rSDB 30 in the C language level debug support environment 110 is a part that supports C language level debugging, and is always used in pair with the rDBM 11 that operates on a workstation and is connected by communication (1
N rSDBs can be connected to one rDBM11). The rSDB 30 and the rDBM 11 are connected via the network interfaces 111 and 121.

The rDBM 11 is an assembler-level debugger and shares execution control and data access functions depending on the target microprocessor such as single step and breakpoint. The rDBM 11 operates on the system process 10 and the target. And
It has functions such as multi-task debug capable of simultaneously debugging a plurality of tasks, multi-rSDB correspondence capable of simultaneously processing commands from a plurality of rSDBs, and a multi-debug mode having an online or offline operation mode.

The present invention is based on the above configuration,
Furthermore, the following thread debug mechanism is added to this. The rDBM 11 is operated as a thread in the debugged process. In this case, the conventional sdb handles the debugged object as a child process, whereas the relationship between the rSDB 30 and the debugged process is not a parent-child relationship but an independent process. The illegal instruction signal of the host machine and the illegal instruction signal of UNIX (SIGILL) are used for the realization of the thread break function in the same way as sdb, but the illegal instruction signal of the breakpoint hit is received from UNIX by rS.
RSDB11 in the debugged process instead of DB30
Received via an asynchronous signal handler. It is particularly emphasized in the present invention that the illegal instruction signal handler of the debugged process directly receives the illegal instruction signal of the breakpoint hit, and r
This is a mechanism for notifying the DBM 11. This illegal instruction signal is generated asynchronously to the non-debug process and is notified to the rDBM 11, so that it does not affect the operation of threads other than the rDBM.

FIG. 3 shows the overall configuration when debugging is performed using the above-mentioned debugger. In the figure, the symbol P indicates that the process is a UNIX process,
The symbol S indicates that the process is a thread.
Reference numeral 200 is a debugged process, and the library 20
1. SIGILL handler 202 and SIGIO handler 203 as asynchronous signal handlers, user thread 204 as debugged thread, and rDBM3
It consists of zero. The SIGILL handler 202 is an asynchronous interrupt handler for command reception from the rSDB 30 when executing an illegal instruction. The SIGIO handler 203 uses rS
It is an asynchronous interrupt handler for receiving a command from the DB 30.

The library 201 includes the following libraries for realizing the thread debug function. Thread management library A kernel implementation thread (not a coroutine library) provided by UNIX, and thread context switching is performed by UNIX. Message management library

The following table is a list of commands relating to thread management and inter-thread messages and their functions.

From SIGIO handler 203 to rDBM1
The message sent to 1 includes a breakpoint hit and a command from the rSDB 30, which is defined by the following structure, for example. #define unsigned char string; #define unsigned long UW; struct t_knlmsgp {/ * Message from the signal handler * / string cmd [8]; / * * "BREAKHIT"-Break hit * "********" -Command from RSDB * * / UW rsdb_sid; / * RSDB communication socket identifier * / UW break_adr; / * Break address (32 bits) * /};

The operation of each section in such a configuration will be described below. (1) Processing of rDBM 11 FIG. 4 shows a list of programs related to this processing. This program is a function that has no arguments and no return value. Also, this listing is for illustration only and is not a complete program listing. In this process, first assume that the message buffer type is the above message structure type, and
Next, an asynchronous communication socket with the rSDB30 is initialized, an illegal command (SIGILL) signal reception handler is defined, and a command reception signal handler (SIGIO) is defined.
After that, the process for waiting for the next message is started. The message sources are rSDB30 and the signal handler. When a message is received, it is divided into the following three processes depending on the type of command.

If the command is a breakpoint hit, it is judged whether or not it is the one intended, and if it is a breakpoint, the following processing is continued, and if not, exception processing is started and the processing waits for a message again. Return. If it is a breakpoint, cancel the breakpoint. Then, the breakpoint is deleted from the breakpoint management table.
Then, using the socket identifier, the requested rSDB30
Notify the break. Then, the process returns to the above message waiting state. If the command is a breakpoint set, save the breakpoint data. Then, the illegal instruction is set and the breakpoint data is registered in the breakpoint management table. Next, the result is notified to the requesting rSDB 30 using the socket identifier. When it ends, it returns to the above message waiting again. When the command is another rSDB command, each rSDB command process is performed. Subsequently, the socket identifier is used to notify the result to the requesting rSDB. After that, the process shifts to the above message waiting.

(2) Processing of illegal instruction signal (SIGILL) handler FIG. 5 shows a processing program. When an illegal instruction is executed, the processing of this handler (sigillhdr ()) is executed.
Then, the break information is transmitted to the rDBM 11. The contents of the processing will be described below. It is assumed that the message buffer type is the message structure type, and the "BREAKHIT" command and the break address are set in the message buffer. Then, the information in the message buffer is stored in rDBM11.
Send to. The rDBM 11 determines whether the address is a break address.

(3) Command reception signal (SIGIO)
Processing of Handler Upon receiving a command from the rSDB 30, the command reception signal handler (sigiohdr ()) shown in FIG. 6 is executed, and the command is transmitted to the rDBM 11. The processing contents are as follows. Assume that the message buffer is of the message structure type, and set the rSDB command and rSDB socket identifier in the message buffer. Then r
Send it to DBM11.

(4) Break Point Setting and Hit Operation The operation will be described step by step with reference to FIG. In addition,
Item numbers a, b, c ,. ． ． Are circled a, b,
c ,. ． ． Corresponding to. (a) A break command is transmitted from the rSDB30. (b) The SIGIO handler 203 of the system process is activated to read the command from the socket. (c) The SIGIO203 handler sends the command to the rDBM11. The waiting of the rDBM message reception is released. (d) Terminate the SIGIO handler and switch the thread to the rDBM11. rDBM is always a higher priority than user thread 204. (e) The rDBM 11 identifies the break command.

(F) The rDBM 11 saves the contents of the breakpoint address obtained from the rSDB 30. The MPU illegal instruction is directly set to the breakpoint address. Then, the rDBM again waits for a command to be received. (g) The execution continuation command is transmitted from the rSDB30 to the rDBM11. Execute the above (b) to (e) in order to continuously execute the thread to be debugged. The rDBM then waits again for command reception. (h) The thread is switched to the debugged thread (user thread 204). (i) A break hit occurs and the SIGILL handler is activated. (j) The SIGILL handler extracts the illegal instruction execution address from the buffer (sigcontext structure). (k) Send a break hit command and an illegal instruction execution address to the rDBM11.

(L) Terminate the SIGIO handler and rDB
Switch threads to M11. (m) The rDBM 11 determines whether the illegal instruction execution address is a breakpoint address. (n) If it is a breakpoint address, the hit thread is forcibly stopped, and if it is not a breakpoint address, exception processing is started. (o) The breakpoint is repaired, and the rDBM 11 waits again for command reception. (p) The debugged thread 204 resumes execution by the continuous execution command from the rSDB30. As described above, it is possible to easily online debug only the thread.

[0029]

As described above, the present invention has the following effects. U due to the spread of thread services
It is required to partially online debug only certain threads without stopping the NIX process.
According to the present invention, online thread debugging can be easily realized by utilizing the thread management function and the inter-thread message function.

[Brief description of drawings]

FIG. 1 is a configuration diagram showing an example of a simulation development environment for realizing the present invention.

FIG. 2 is a configuration diagram of an embodiment of a C language level debugger.

FIG. 3 is a configuration diagram showing an embodiment of a thread online debug device according to the present invention.

FIG. 4 is a diagram for explaining processing contents of rDBM.

FIG. 5 is a diagram for explaining processing contents of an illegal instruction signal handler.

FIG. 6 is a diagram for explaining processing contents of a command reception signal handler.

FIG. 7 is a diagram for explaining a breakpoint setting operation and a hit operation.

FIG. 8 is a diagram showing a debug mode of sdb.

FIG. 9 is a diagram showing a flow of basic processing of sdb.

[Explanation of symbols]

 10 system process 11 rDBM 12 thread 20 asynchronous signal handler 30 rSDB 40 UNIX 100 C language level debugger 110 C language level debugging support environment 120 assembler level debugger 200 debugged process 201 library 202 SIGIO handler 203 SIGILL handler 204 debugged thread

Claims (1)

[Claims] 1. A assembler-level debugger that supports C-level debugging and a remote debug monitor having execution control and data access functions dependent on the target microprocessor unit such as single step and breakpoints. An online debug device comprising a remote source code debugger used in communication with the remote debug monitor, the remote debug monitor operating as a thread in a debugged process. At the same time, it is treated as a process independent from the process to be debugged, and the illegal online instruction signal of breakpoint hit is received via an asynchronous signal handler.